mosaico 1.0.0

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/if-subs.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var ko = require("knockout");
+var console = require("console");
+
+ko.bindingHandlers['ifSubs'] = {
+  // cloneNodes from ko.utils.cloneNodes (missing in minimized KO)
+  cloneNodes: function(nodesArray, shouldCleanNodes) {
+    for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {
+      var clonedNode = nodesArray[i].cloneNode(true);
+      newNodesArray.push(shouldCleanNodes ? ko.cleanNode(clonedNode) : clonedNode);
+    }
+    return newNodesArray;
+  },
+  'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
+    var didDisplayOnLastUpdate,
+      savedNodes,
+      valueAcc = valueAccessor();
+    if (typeof valueAcc.data.subsCount === 'undefined') {
+      ko.extenders['subscriptionsCount'](valueAcc.data);
+      // NOTE I can't simply listen on "thresholds" because multiple bindings to the same observable could use different thresholds.
+    }
+    ko.computed(function() {
+      var dataValue = ko.utils.unwrapObservable(valueAccessor().data.subsCount),
+        isFirstRender = !savedNodes,
+        shouldDisplay, needsRefresh, gutter;
+
+      gutter = -(typeof valueAccessor().gutter !== 'undefined' ? valueAccessor().gutter : 1);
+      shouldDisplay = dataValue + (didDisplayOnLastUpdate ? gutter : 0) >= ko.utils.unwrapObservable(valueAcc.threshold);
+      if (typeof valueAccessor().not !== 'undefined' && valueAccessor().not) {
+        shouldDisplay = !shouldDisplay;
+      }
+      needsRefresh = isFirstRender || (shouldDisplay !== didDisplayOnLastUpdate);
+
+      if (needsRefresh) {
+        // Save a copy of the inner nodes on the initial update, but only if we have dependencies.
+        if (isFirstRender && ko.computedContext.getDependenciesCount()) {
+          savedNodes = ko.bindingHandlers['ifSubs'].cloneNodes(ko.virtualElements.childNodes(element), true /* shouldCleanNodes */ );
+        }
+
+        if (shouldDisplay) {
+          if (!isFirstRender) {
+            ko.virtualElements.setDomNodeChildren(element, ko.bindingHandlers['ifSubs'].cloneNodes(savedNodes));
+          }
+          ko.applyBindingsToDescendants(bindingContext, element);
+        } else {
+          ko.virtualElements.emptyNode(element);
+        }
+
+        didDisplayOnLastUpdate = shouldDisplay;
+      }
+    }, null, {
+      disposeWhenNodeIsRemoved: element
+    });
+    return {
+      'controlsDescendantBindings': true
+    };
+  }
+};
+ko.virtualElements.allowedBindings['ifSubs'] = true;
+
+// ko.isWritableObservable (without "e") has been introduced in 3.2.0, that is also our min requirement.
+// minimized knockout "obfuscate" the beforeSubscriptionAdd and afterSubscriptionRemove methods that we hack here.
+// so we have to explicitly know that.
+// Note: we used to use ko.DEBUG to detect the debug version of KO, but this was removed in KO 3.4.0+, 
+//       so we switched to ko.subscription function that only exists in DEBUG versions.
+var beforeSubscriptionProp;
+var afterSubscriptionProp;
+if (typeof ko.subscription == 'function' && typeof ko.isWritableObservable !== 'undefined') {
+  beforeSubscriptionProp = 'beforeSubscriptionAdd';
+  afterSubscriptionProp = 'afterSubscriptionRemove';
+} else if (ko.version == "3.2.0") {
+  beforeSubscriptionProp = 'va';
+  afterSubscriptionProp = 'nb';
+} else if (ko.version == "3.3.0") {
+  beforeSubscriptionProp = 'ja';
+  afterSubscriptionProp = 'ua';
+} else if (ko.version == "3.4.0") {
+  beforeSubscriptionProp = 'sa';
+  afterSubscriptionProp = 'Ia';
+} else if (ko.version == "3.4.1") {
+  beforeSubscriptionProp = 'sa';
+  afterSubscriptionProp = 'Ia';
+}
+else throw "Unsupported minimized Knockout version " + ko.version + " (supported DEBUG or minimized 3.2.0 ... 3.4.1)";
+
+// internally used by ifsubs binding.
+// WARNING this break when used with pureComputed or deferredEvaluated
+ko.extenders['subscriptionsCount'] = function(target, l1, l2) {
+  if (typeof target.subsCount === 'undefined') {
+    target.subsCount = ko.observable(target.getSubscriptionsCount()).extend({
+      notify: 'always'
+    });
+    var underlyingBeforeSubscriptionAddFunction = target[beforeSubscriptionProp];
+    var underlyingAfterSubscriptionRemoveFunction = target[afterSubscriptionProp];
+    target[beforeSubscriptionProp] = function(event) {
+      if (underlyingBeforeSubscriptionAddFunction) underlyingBeforeSubscriptionAddFunction.call(target, event);
+      var c = target.getSubscriptionsCount() + 1;
+      if (typeof l1 === 'undefined' || c == l1 || typeof l2 === 'undefined' || c == l2) target.subsCount(c);
+    };
+    target[afterSubscriptionProp] = function(event) {
+      if (underlyingAfterSubscriptionRemoveFunction) underlyingAfterSubscriptionRemoveFunction.call(target, event);
+      var c = target.getSubscriptionsCount();
+      if (typeof l1 === 'undefined' || c == l1 || typeof l2 === 'undefined' || c == l2) target.subsCount(c);
+    };
+  } else {
+    console.log("already applied subscriptionCount to observable");
+  }
+  return null;
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/jqueryui-spinner.js

@@ -0,0 +1,31 @@
+"use strict";
+
+// Overrides native jQuery spinner to avoid validation of the "step".
+// We wants to use the step but also wants to leave the user the ability to select specific values.
+
+var $ = require('jquery');
+var spinner = require("jquery-ui/spinner");
+var console = require('console');
+
+if (typeof spinner == 'undefined') throw "Cannot find jquery-ui spinner widget dependency!";
+
+$.widget("ui.spinner", spinner, {
+  _adjustValue: function(value) {
+    var adj = this._super(value);
+
+    var options = this.options;
+
+    // fix precision from bad JS floating point math
+    value = parseFloat(value.toFixed(this._precision()));
+
+    // clamp the value
+    if (options.max !== null && value > options.max) {
+      return options.max;
+    }
+    if (options.min !== null && value < options.min) {
+      return options.min;
+    }
+
+    return value;
+  }
+});

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/jqueryui-tabs.js

@@ -0,0 +1,17 @@
+"use strict";
+
+// Overrides native jQuery tabs to make tabs working also when using a base tag
+// in order to avoid conflicts you have to add a data-local="true" attribute to your tab links.
+
+var $ = require('jquery');
+var console = require('console');
+var tabs = require("jquery-ui/tabs");
+
+if (typeof tabs == 'undefined') throw "Cannot find jquery-ui tabs widget dependency!";
+
+$.widget("ui.tabs", tabs, {
+  _isLocal: function( anchor ) {
+    if (anchor.getAttribute('data-local') == "true") return true;
+    else return this._superApply( arguments );
+  }
+});

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/script-template.js

@@ -0,0 +1,30 @@
+"use strict";
+/* globals global: false */
+
+function pushTemplate(templateName, templateText) {
+  var scriptTag = global.document.createElement('script');
+  scriptTag.setAttribute('type', 'text/html');
+  scriptTag.setAttribute('id', templateName);
+  scriptTag.text = templateText;
+  global.document.body.appendChild(scriptTag);
+}
+
+function removeTemplate(templateName) {
+  var el = global.document.getElementById(templateName);
+  if (el) el.parentNode.removeChild(el);
+}
+
+function init() {}
+
+function getTemplateContent(id) {
+  var el = global.document.getElementById(id);
+  if (el) return el.innerHTML;
+  else return undefined;
+}
+
+module.exports = {
+  init: init,
+  addTemplate: pushTemplate,
+  removeTemplate: removeTemplate,
+  getTemplateContent: getTemplateContent
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/scrollfix.js

@@ -0,0 +1,48 @@
+"use strict";
+/* global global: false */
+
+var ko = require("knockout");
+var $ = require("jquery");
+var console = require("console");
+var tinymce = require("tinymce");
+
+var timeout;
+
+var render = function() {
+
+  timeout = undefined;
+
+  if (typeof tinymce.activeEditor !== 'undefined' && tinymce.activeEditor !== null &&
+      typeof tinymce.activeEditor.theme !== 'undefined' && tinymce.activeEditor.theme !== null && 
+      typeof tinymce.activeEditor.theme.panel !== 'undefined' && tinymce.activeEditor.theme.panel !== null &&
+      typeof tinymce.activeEditor.theme.panel.visible !== 'undefined') {
+    // @see FloatPanel.js function repositionPanel(panel)
+    // First condition group is for Tinymce 4.0/4.1
+    // Second condition group is for Tinymce 4.2/4.3 where "._property" are now available as ".state.get('property')".
+    if ((typeof tinymce.activeEditor.theme.panel._visible !== 'undefined' && tinymce.activeEditor.theme.panel._visible && tinymce.activeEditor.theme.panel._fixed) || 
+        (typeof tinymce.activeEditor.theme.panel.state !== 'undefined' && tinymce.activeEditor.theme.panel.state.get('visible') && tinymce.activeEditor.theme.panel.state.get('fixed'))) {
+      tinymce.activeEditor.theme.panel.fixed(false);
+    }
+
+    tinymce.activeEditor.nodeChanged();
+    tinymce.activeEditor.theme.panel.visible(true);
+    if (tinymce.activeEditor.theme.panel.layoutRect().y <= 40)
+      tinymce.activeEditor.theme.panel.moveBy(0, 40 - tinymce.activeEditor.theme.panel.layoutRect().y);
+
+  }
+};
+
+ko.bindingHandlers.wysiwygScrollfix = {
+  'scroll': function(event) {
+    if (timeout) global.clearTimeout(timeout);
+    timeout = global.setTimeout(render, 50);
+  },
+  'init': function(element) {
+    ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+      $(element).off("scroll", ko.bindingHandlers.wysiwygScrollfix.scroll);
+    });
+
+    $(element).on("scroll", ko.bindingHandlers.wysiwygScrollfix.scroll);
+
+  }
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/scrollintoview.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var $ = require("jquery");
+var ko = require("knockout");
+var console = require("console");
+
+var _scrollIntoView = function($element, alignTop, scrollParent, moveBy) {
+  var currentScrollTop = scrollParent.scrollTop();
+  var newScrollTop = currentScrollTop - moveBy - (alignTop ? 20 : -20);
+  // iframe scrolls the window and animation is not supported
+  var animate = typeof scrollParent[0].nodeType !== 'undefined';
+  if (animate) {
+    var action = {
+      'scrollTop': "" + Math.round(newScrollTop) + "px"
+    };
+    var time = Math.round(Math.abs(newScrollTop - currentScrollTop));
+    scrollParent.stop().animate(action, time);
+  } else {
+    scrollParent.scrollTop(newScrollTop);
+  }
+  // native scrollIntoView is not well supported and doesn't work fine.
+  // element.scrollIntoView(alignTop);
+};
+
+ko.bindingHandlers.scrollIntoView = {
+  update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+    var selected = ko.utils.unwrapObservable(valueAccessor());
+    if (!selected) return;
+    try {
+
+      while (element.nodeType === 8) {
+        // element is a comment, move to the next sibling...
+        element = element.nextSibling;
+      }
+      if (element.nodeType !== 8) {
+        var scrollParent = $(element).scrollParent();
+
+        var parentTop;
+        var relativeOffset = false;
+        if (scrollParent[0].nodeType == 9) {
+          // scrollparent is document, replacing with body...
+          scrollParent = $(scrollParent[0].defaultView);
+          parentTop = 0;
+          relativeOffset = true;
+        } else {
+          parentTop = scrollParent.offset().top;
+        }
+
+        var parentHeight = scrollParent.height();
+        var parentScroll = scrollParent.scrollTop();
+        var parentBottom = parentTop + parentHeight;
+
+        // scrollParent is the document.
+        var $element = $(element);
+        var elTop = $element.offset().top;
+        // when we are in "iframe" with scrollbar everythijng changes.
+        if (relativeOffset) elTop = elTop - parentScroll;
+        var elHeight = $element.height();
+        var elBottom = elTop + elHeight;
+        if (elTop > parentTop && elTop + elHeight < parentBottom) {
+          // both borders are visible => don't do anything.
+        } else if (elHeight < parentHeight) {
+          // if the block is smaller than the viewPort
+          if (elTop < parentTop) _scrollIntoView(element, true, scrollParent, parentTop - elTop);
+          // -> if the upper border is higher than the top, then I move it to the top.
+          if (elBottom > parentBottom) _scrollIntoView(element, false, scrollParent, parentBottom - elBottom);
+          // -> if the bottom border is lower than the bottom then I move it to the bottom.
+        } else {
+          // if the block is larger than the viewPort we do the opposite!
+          // -> if the upper border is higher than the top and the lower is higher than the bottom I move the lower it to the bottom.
+          if (elTop < parentTop && elBottom < parentBottom) _scrollIntoView(element, false, scrollParent, parentBottom - elBottom);
+          // -> if the bottom border il lower than bottom and the upper is lower than the top I move the upper border to the viewport top
+          if (elTop > parentTop && elBottom > parentBottom) _scrollIntoView(element, true, scrollParent, parentTop - elTop);
+        }
+
+        // element.scrollIntoView(true);
+      }
+    } catch (e) {
+      console.log("TODO exception scrolling into view", e);
+    }
+  }
+};
+ko.virtualElements.allowedBindings['scrollIntoView'] = true;

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/string-template.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var ko = require("knockout");
+var origTemplateSystem = require("./script-template.js");
+
+var templates = {};
+
+//define a template source that simply treats the template name as its content
+ko.templateSources.stringTemplate = function(templateName, template) {
+  this.templateName = templateName;
+  this.template = template;
+  this._data = {};
+};
+
+ko.utils.extend(ko.templateSources.stringTemplate.prototype, {
+  data: function(key, value) {
+    // console.log("data", key, value, this.templateName);
+    if (arguments.length === 1) {
+      return this._data[key];
+    }
+
+    this._data[key] = value;
+  },
+  text: function(value) {
+    // console.log("text", value, this.templateName)
+    if (arguments.length === 0) {
+      return this.template;
+    }
+    this.template = value;
+  }
+});
+
+
+//modify an existing templateEngine to work with string templates
+function createStringTemplateEngine(templateEngine) {
+  var orig = templateEngine.makeTemplateSource;
+  templateEngine.makeTemplateSource = function(templateName) {
+    if (typeof templates[templateName] !== 'undefined') {
+      return new ko.templateSources.stringTemplate(templateName, templates[templateName]);
+    } else {
+      return orig(templateName);
+    }
+  };
+  return templateEngine;
+}
+
+function pushTemplate(templateName, templateText) {
+  templates[templateName] = templateText;
+}
+
+function removeTemplate(templateName) {
+  if (typeof templates[templateName] !== 'undefined') {
+    templates[templateName] = undefined;
+  } else {
+    origTemplateSystem.removeTemplate(templateName);
+  }
+}
+
+function init() {
+  ko.setTemplateEngine(createStringTemplateEngine(new ko.nativeTemplateEngine()));
+}
+
+function getTemplateContent(id) {
+  if (typeof templates[id] !== 'undefined') {
+    return templates[id];
+  } else {
+    return origTemplateSystem.getTemplateContent(id);
+  }
+}
+
+module.exports = {
+  init: init,
+  addTemplate: pushTemplate,
+  removeTemplate: removeTemplate,
+  getTemplateContent: getTemplateContent
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/tooltips.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var ko = require("knockout");
+var $ = require("jquery");
+var kojqui = require("knockout-jqueryui");
+var console = require("console");
+
+var extendValueAccessor = function(valueAccessor, obj) {
+  return function() {
+    ko.utils.extend(obj, valueAccessor());
+    return obj;
+  };
+};
+
+var options = {
+  show: {
+    delay: 500
+  },
+  track: true,
+  items: '[title][title!=""][title!=" "]'
+};
+
+ko.bindingHandlers.tooltips = {
+  init: function(element, valueAccessor, allBindingsAccessor, data, context) {
+    if (typeof $.fn.tooltip !== 'undefined' && typeof ko.bindingHandlers.tooltip !== 'undefined') {
+      // position: { my: "left+15 top+15", at: "center+30 center+30" }
+      // NOTE title with "" and " " is needed to avoid default tooltips in native file upload controls
+      return ko.bindingHandlers.tooltip.init(element, extendValueAccessor(valueAccessor, options), allBindingsAccessor, data, context);
+    }
+  },
+  update: function(element, valueAccessor, allBindingsAccessor, data, context) {
+    if (typeof $.fn.tooltip !== 'undefined' && typeof ko.bindingHandlers.tooltip !== 'undefined') {
+      return ko.bindingHandlers.tooltip.update(element, extendValueAccessor(valueAccessor, options), allBindingsAccessor, data, context);
+    }
+  },
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/validated-value.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var ko = require('knockout');
+var console = require('console');
+
+// equals to "value" binding but apply "invalid" class if "pattern" attribute is defined and value matches the rule
+ko.bindingHandlers['validatedValue'] = {
+	init: function(element, valueAccessor, allBindings) {
+		var newValueAccessor = valueAccessor;
+		if (typeof element.pattern !== 'undefined') {
+			var re = new RegExp('^(?:' + element.pattern + ')$');
+			var computed = ko.computed({
+				read: function() {
+					var res = ko.utils.unwrapObservable(valueAccessor());
+					// TODO support for element.required ?
+					var valid = res === null || res === '' || re.test(res);
+					// IE11 doesn't support classList.toggle('invalid', state)
+					if (valid) {
+						element.classList.remove('invalid');
+					} else {
+						element.classList.add('invalid');
+					}
+					return res;
+				},
+				write: ko.isWriteableObservable(valueAccessor()) && function(value) {
+					// @see https://github.com/voidlabs/mosaico/issues/103
+					ko.selectExtensions.writeValue(element, value);
+					var updValue = ko.selectExtensions.readValue(element);
+					valueAccessor()(updValue);
+				},
+				disposeWhenNodeIsRemoved: element
+			});
+			newValueAccessor = function() {
+				return computed;
+			};
+		}
+		ko.bindingHandlers['value'].init(element, newValueAccessor, allBindings);
+	}
+};
+ko.expressionRewriting._twoWayBindings['validatedValue'] = true;