kdutify 0.16.9-rc.0

package/es5/util/helpers.js

@@ -0,0 +1,139 @@
+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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+export function createSimpleFunctional(c) {
+  var el = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'div';
+  var name = arguments[2];
+
+  name = name || c.replace(/__/g, '-');
+
+  return {
+    name: 'k-' + name,
+    functional: true,
+
+    render: function render(h, _ref) {
+      var data = _ref.data,
+          children = _ref.children;
+
+      data.staticClass = (c + ' ' + (data.staticClass || '')).trim();
+
+      return h(el, data, children);
+    }
+  };
+}
+
+export function createSimpleTransition(name) {
+  var origin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top center 0';
+  var mode = arguments[2];
+
+  return {
+    name: name,
+
+    functional: true,
+
+    props: {
+      origin: {
+        type: String,
+        default: origin
+      }
+    },
+
+    render: function render(h, context) {
+      context.data = context.data || {};
+      context.data.props = { name: name };
+      context.data.on = context.data.on || {};
+      if (!Object.isExtensible(context.data.on)) {
+        context.data.on = _extends({}, context.data.on);
+      }
+
+      if (mode) context.data.props.mode = mode;
+
+      context.data.on.beforeEnter = function (el) {
+        el.style.transformOrigin = context.props.origin;
+        el.style.webkitTransformOrigin = context.props.origin;
+      };
+
+      return h('transition', context.data, context.children);
+    }
+  };
+}
+
+export function createJavaScriptTransition(name, functions) {
+  var css = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  var mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'in-out';
+
+  return {
+    name: name,
+
+    functional: true,
+
+    props: {
+      css: {
+        type: Boolean,
+        default: css
+      },
+      mode: {
+        type: String,
+        default: mode
+      }
+    },
+
+    render: function render(h, context) {
+      var data = {
+        props: _extends({}, context.props, {
+          name: name
+        }),
+        on: functions
+      };
+
+      return h('transition', data, context.children);
+    }
+  };
+}
+
+export function directiveConfig(binding) {
+  var defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  return Object.assign({}, defaults, binding.modifiers, { value: binding.arg }, binding.value || {});
+}
+
+export function addOnceEventListener(el, event, cb) {
+  var once = function once() {
+    cb();
+    el.removeEventListener(event, once, false);
+  };
+
+  el.addEventListener(event, once, false);
+}
+
+export function getObjectValueByPath(obj, path) {
+  // credit: http://stackoverflow.com/questions/6491463/accessing-nested-javascript-objects-with-string-key#comment55278413_6491621
+  if (!path || path.constructor !== String) return;
+  path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
+  path = path.replace(/^\./, ''); // strip a leading dot
+  var a = path.split('.');
+  for (var i = 0, n = a.length; i < n; ++i) {
+    var k = a[i];
+    if (obj instanceof Object && k in obj) {
+      obj = obj[k];
+    } else {
+      return;
+    }
+  }
+  return obj;
+}
+
+export function createRange(length) {
+  return [].concat(_toConsumableArray(Array.from({ length: length }, function (v, k) {
+    return k;
+  })));
+}
+
+export function getZIndex(el) {
+  if (!el || el.nodeType !== Node.ELEMENT_NODE) return 0;
+  var zi = document.defaultView.getComputedStyle(el).getPropertyValue('z-index');
+  if (isNaN(zi)) return getZIndex(el.parentNode);
+
+  return zi;
+}

package/es5/util/load.js

@@ -0,0 +1,15 @@
+function load(cb) {
+  var i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+  if (!document._loadCallbacks) {
+    document._loadCallbacks = [];
+  }
+
+  if (document.readyState === 'complete') {
+    return cb();
+  }
+
+  document._loadCallbacks.push(cb);
+}
+
+export default load;

package/es5/util/mask.js

@@ -0,0 +1,159 @@
+/**
+ * Mask keys
+ *
+ * @type {Object}
+ */
+var allowedMasks = {
+  '#': {
+    test: function test(char) {
+      return char.match(/[0-9]/);
+    }
+  },
+  'A': {
+    test: function test(char) {
+      return char.match(/[A-Z]/i);
+    },
+    convert: function convert(char) {
+      return char.toUpperCase();
+    }
+  },
+  'a': {
+    test: function test(char) {
+      return char.match(/[a-z]/i);
+    },
+    convert: function convert(char) {
+      return char.toLowerCase();
+    }
+  },
+  'N': {
+    test: function test(char) {
+      return char.match(/[0-9A-Z]/i);
+    },
+    convert: function convert(char) {
+      return char.toUpperCase();
+    }
+  },
+  'n': {
+    test: function test(char) {
+      return char.match(/[0-9a-z]/i);
+    },
+    convert: function convert(char) {
+      return char.toLowerCase();
+    }
+  },
+  'X': {
+    test: isMaskDelimiter
+  }
+
+  /**
+   * Default delimiter RegExp
+   *
+   * @type {RegExp}
+   */
+};export var defaultDelimiters = /[-!$%^&*()_+|~=`{}\[\]:";'<>?,.\/\\ ]/;
+
+/**
+ * Is Character mask
+ *
+ * @param  {String} char
+ *
+ * @return {Boolean}
+ */
+var isMask = function isMask(char) {
+  return allowedMasks.hasOwnProperty(char);
+};
+
+/**
+ * Automatically convert char case
+ *
+ * @param  {String} mask
+ * @param  {String} char
+ *
+ * @return {String}
+ */
+var convert = function convert(mask, char) {
+  return allowedMasks[mask].convert ? allowedMasks[mask].convert(char) : char;
+};
+
+/**
+ *
+ * @param {String} char
+ *
+ * @return {Boolean}
+ */
+export var isMaskDelimiter = function isMaskDelimiter(char) {
+  return char && char.match(defaultDelimiters);
+};
+
+/**
+ * Mask Validation
+ *
+ * @param  {String} mask
+ * @param  {String} char
+ *
+ * @return {Boolean}
+ */
+var maskValidates = function maskValidates(mask, char) {
+  if (char == null || !isMask(mask)) return false;
+  return allowedMasks[mask].test(char);
+};
+
+/**
+ * Mask Text
+ *
+ * Takes an array of characters
+ * and returns a compiled str
+ *
+ * @param {*} text
+ * @param {Array|String} masked
+ * @param {Boolean} [dontFillMaskBlanks]
+ *
+ * @return {String}
+ */
+export var maskText = function maskText(text, masked, dontFillMaskBlanks) {
+  if (text == null) return '';
+  text = String(text);
+  if (!masked.length || !text.length) return text;
+  if (!Array.isArray(masked)) masked = masked.split('');
+
+  var textIndex = 0;
+  var maskIndex = 0;
+  var newText = '';
+  while (maskIndex < masked.length) {
+    var mask = masked[maskIndex];
+
+    // Assign the next character
+    var char = text[textIndex];
+
+    // Check if mask is delimiter
+    // and current char matches
+    if (!isMask(mask) && char === mask) {
+      newText += mask;
+      textIndex++;
+      // Check if not mask
+    } else if (!isMask(mask) && !dontFillMaskBlanks) {
+      newText += mask;
+      // Check if is mask and validates
+    } else if (maskValidates(mask, char)) {
+      newText += convert(mask, char);
+      textIndex++;
+    } else {
+      return newText;
+    }
+
+    maskIndex++;
+  }
+
+  return newText;
+};
+
+/**
+ * Unmask Text
+ *
+ * @param {String} text
+ *
+ * @return {String}
+ */
+export var unmaskText = function unmaskText(text) {
+  return text.replace(new RegExp(defaultDelimiters, 'g'), '');
+};

package/es5/util/testing.js

@@ -0,0 +1,160 @@
+import Kdu from 'kdu';
+import load from '~util/load';
+import { mount, shallow } from 'avoriaz';
+import toHaveBeenWarnedInit from '~util/to-have-been-warned';
+
+export function test(name, cb) {
+  toHaveBeenWarnedInit();
+
+  Kdu.prototype.$kdutify = {
+    load: function load(fn) {
+      return fn();
+    },
+    breakpoint: {}
+
+    /*
+      const app = document.createElement('div')
+      app.setAttribute('data-app', true)
+      document.body.appendChild(app)
+    */
+
+  };rafPolyfill(window);
+
+  describe(name, function () {
+    return cb({
+      functionalContext: functionalContext,
+      mount: mount,
+      shallow: shallow
+    });
+  });
+}
+
+test.skip = describe.skip;
+
+export function functionalContext() {
+  var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  if (!Array.isArray(children)) children = [children];
+  return {
+    context: Object.assign({
+      data: {},
+      props: {}
+    }, context),
+    children: children
+  };
+}
+
+//requestAnimationFrame polyfill | Milos Djakonovic ( @Miloshio ) | MIT | https://github.com/milosdjakonovic/requestAnimationFrame-polyfill
+export function rafPolyfill(w) {
+  /**
+   *
+   * How many times should polyfill call
+   * update callback? By canon, it should
+   * be 60 times per second, so that ideal
+   * framerate 60fps could be reached.
+   *
+   * However, even native implementations
+   * of requestAnimationFrame often cannot
+   * do 60fps, but, unlike any polyfill,
+   * they can synchronise achievable fps
+   * rate with screen refresh rate.
+   *
+   * So, leave this value 1000/60 unless
+   * you target specific browser on spec
+   * ific device that is going to work
+   * better with custom value. I think
+   * that this is the longest comment I've
+   * written on single variable so far.
+  **/
+  var FRAME_RATE_INTERVAL = 1000 / 60,
+
+
+  /**
+   * All queued callbacks in given cycle.
+  **/
+  allCallbacks = [],
+      executeAllScheduled = false,
+      shouldCheckCancelRaf = false,
+
+
+  /**
+   * Callbacks queued for cancellation.
+  **/
+  callbacksForCancellation = [],
+
+
+  /**
+   * Should callback be cancelled?
+   * @param cb - callback
+  **/
+  isToBeCancelled = function isToBeCancelled(cb) {
+    for (var i = 0; i < callbacksForCancellation.length; i++) {
+      if (callbacksForCancellation[i] === cb) {
+        callbacksForCancellation.splice(i, 1);
+        return true;
+      }
+    }
+  },
+
+
+  /**
+   *
+   * Executes all (surprise) callbacks in
+   * and removes them from callback queue.
+   *
+  **/
+  executeAll = function executeAll() {
+    executeAllScheduled = false;
+    var _allCallbacks = allCallbacks;
+    allCallbacks = [];
+    for (var i = 0; i < _allCallbacks.length; i++) {
+      if (shouldCheckCancelRaf === true) {
+        if (isToBeCancelled(_allCallbacks[i])) {
+          shouldCheckCancelRaf = false;
+          return;
+        }
+      }
+      _allCallbacks[i].apply(w, [new Date().getTime()]);
+    }
+  },
+
+
+  /**
+   *
+   * requestAnimationFrame polyfill
+   * @param callback - callback to be queued & executed | executed
+   * @return callback
+   *
+  **/
+  raf = function raf(callback) {
+    allCallbacks.push(callback);
+    if (executeAllScheduled === false) {
+      w.setTimeout(executeAll, FRAME_RATE_INTERVAL);
+      executeAllScheduled = true;
+    }
+    return callback;
+  },
+
+
+  /**
+   *
+   * Cancels raf.
+  **/
+  cancelRaf = function cancelRaf(callback) {
+    callbacksForCancellation.push(callback);
+    shouldCheckCancelRaf = true;
+  },
+
+
+  //https://gist.github.com/paulirish/1579671
+  vendors = ['ms', 'moz', 'webkit', 'o'];
+
+  for (var x = 0; x < vendors.length && !w.requestAnimationFrame; ++x) {
+    w.requestAnimationFrame = w[vendors[x] + 'RequestAnimationFrame'];
+    w.cancelAnimationFrame = w[vendors[x] + 'CancelAnimationFrame'] || w[vendors[x] + 'CancelRequestAnimationFrame'];
+  }
+
+  if (!w.requestAnimationFrame) w.requestAnimationFrame = raf;
+  if (!w.cancelAnimationFrame) w.cancelAnimationFrame = cancelRaf;
+}

package/es5/util/to-have-been-warned.js

@@ -0,0 +1,117 @@
+// From Kdu, slightly modified
+
+function noop() {}
+
+if (typeof console === 'undefined') {
+  window.console = {
+    warn: noop,
+    error: noop
+  };
+}
+
+// avoid info messages during test
+console.info = noop;
+
+var asserted = [];
+
+function createCompareFn(spy) {
+  var hasWarned = function hasWarned(msg) {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = spy.calls.allArgs()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var args = _step.value;
+
+        if (args.some(function (arg) {
+          return arg.toString().includes(msg);
+        })) return true;
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
+
+  return {
+    compare: function compare(msg) {
+      asserted.push(msg);
+      var warned = Array.isArray(msg) ? msg.some(hasWarned) : hasWarned(msg);
+      return {
+        pass: warned,
+        message: warned ? 'Expected message "' + msg + '" not to have been warned' : 'Expected message "' + msg + '" to have been warned'
+      };
+    }
+  };
+}
+
+function toHaveBeenWarnedInit() {
+  // define custom matcher for warnings
+  beforeEach(function () {
+    asserted.length = 0;
+    spyOn(console, 'warn');
+    spyOn(console, 'error');
+    jasmine.addMatchers({
+      toHaveBeenWarned: function toHaveBeenWarned() {
+        return createCompareFn(console.error);
+      },
+      toHaveBeenTipped: function toHaveBeenTipped() {
+        return createCompareFn(console.warn);
+      }
+    });
+  });
+
+  afterEach(function (done) {
+    var _arr = ['error', 'warn'];
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      var type = _arr[_i];
+      var warned = function warned(msg) {
+        return asserted.some(function (assertedMsg) {
+          return msg.toString().includes(assertedMsg);
+        });
+      };
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = console[type].calls.allArgs()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var args = _step2.value;
+
+          if (!warned(args[0])) {
+            done.fail('Unexpected console.' + type + ' message: ' + args[0]);
+            return;
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+    done();
+  });
+}
+
+export default toHaveBeenWarnedInit;

package/es5/util/touchSupport.js

@@ -0,0 +1,14 @@
+import { addOnceEventListener } from './helpers';
+
+/**
+ * @mixin
+ */
+export default {
+  mounted: function mounted() {
+    var _this = this;
+
+    addOnceEventListener(window, 'touchstart', function () {
+      _this.$kdutify.touchSupport = true;
+    });
+  }
+};

package/index.d.ts

@@ -0,0 +1,8 @@
+import './src/util/helpers'
+import { PluginFunction } from 'kdu'
+
+declare class Kdutify {
+  static install: PluginFunction<never>
+}
+
+export = Kdutify