nyc-planning-style-guide
Version:
Base styles for NYC Department of City Planning (using Foundation for Sites)
1,275 lines (1,210 loc) • 740 kB
JavaScript
/******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ "./node_modules/foundation-sites/dist/js/foundation.esm.js":
/*!*****************************************************************!*\
!*** ./node_modules/foundation-sites/dist/js/foundation.esm.js ***!
\*****************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ Abide: function() { return /* binding */ Abide; },
/* harmony export */ Accordion: function() { return /* binding */ Accordion; },
/* harmony export */ AccordionMenu: function() { return /* binding */ AccordionMenu; },
/* harmony export */ Box: function() { return /* binding */ Box; },
/* harmony export */ Core: function() { return /* binding */ Foundation; },
/* harmony export */ CoreUtils: function() { return /* binding */ foundation_core_utils; },
/* harmony export */ Drilldown: function() { return /* binding */ Drilldown; },
/* harmony export */ Dropdown: function() { return /* binding */ Dropdown; },
/* harmony export */ DropdownMenu: function() { return /* binding */ DropdownMenu; },
/* harmony export */ Equalizer: function() { return /* binding */ Equalizer; },
/* harmony export */ Foundation: function() { return /* binding */ Foundation; },
/* harmony export */ Interchange: function() { return /* binding */ Interchange; },
/* harmony export */ Keyboard: function() { return /* binding */ Keyboard; },
/* harmony export */ Magellan: function() { return /* binding */ Magellan; },
/* harmony export */ MediaQuery: function() { return /* binding */ MediaQuery; },
/* harmony export */ Motion: function() { return /* binding */ Motion; },
/* harmony export */ Move: function() { return /* binding */ Move; },
/* harmony export */ Nest: function() { return /* binding */ Nest; },
/* harmony export */ OffCanvas: function() { return /* binding */ OffCanvas; },
/* harmony export */ Orbit: function() { return /* binding */ Orbit; },
/* harmony export */ ResponsiveAccordionTabs: function() { return /* binding */ ResponsiveAccordionTabs; },
/* harmony export */ ResponsiveMenu: function() { return /* binding */ ResponsiveMenu; },
/* harmony export */ ResponsiveToggle: function() { return /* binding */ ResponsiveToggle; },
/* harmony export */ Reveal: function() { return /* binding */ Reveal; },
/* harmony export */ Slider: function() { return /* binding */ Slider; },
/* harmony export */ SmoothScroll: function() { return /* binding */ SmoothScroll; },
/* harmony export */ Sticky: function() { return /* binding */ Sticky; },
/* harmony export */ Tabs: function() { return /* binding */ Tabs; },
/* harmony export */ Timer: function() { return /* binding */ Timer; },
/* harmony export */ Toggler: function() { return /* binding */ Toggler; },
/* harmony export */ Tooltip: function() { return /* binding */ Tooltip; },
/* harmony export */ Touch: function() { return /* binding */ Touch; },
/* harmony export */ Triggers: function() { return /* binding */ Triggers; },
/* harmony export */ onImagesLoaded: function() { return /* binding */ onImagesLoaded; }
/* harmony export */ });
/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js");
/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__);
function _typeof2(obj) { "@babel/helpers - typeof"; return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof2(obj); }
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof(obj) {
return typeof obj;
};
} else {
_typeof = function _typeof(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a 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);
}
}
function _createClass(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");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _possibleConstructorReturn(self, call) {
if (call && (_typeof2(call) === "object" || typeof call === "function")) {
return call;
} else if (call !== void 0) {
throw new TypeError("Derived constructors may only return object or undefined");
}
return _assertThisInitialized(self);
}
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = _getPrototypeOf(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possibleConstructorReturn(this, result);
};
}
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = _getPrototypeOf(object);
if (object === null) break;
}
return object;
}
function _get(target, property, receiver) {
if (typeof Reflect !== "undefined" && Reflect.get) {
_get = Reflect.get;
} else {
_get = function _get(target, property, receiver) {
var base = _superPropBase(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(receiver);
}
return desc.value;
};
}
return _get(target, property, receiver || target);
}
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
function _iterableToArrayLimit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for (_i = _i.call(arr); !(_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"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
/**
* Returns a boolean for RTL support
*/
function rtl() {
return jquery__WEBPACK_IMPORTED_MODULE_0___default()('html').attr('dir') === 'rtl';
}
/**
* returns a random base-36 uid with namespacing
* @function
* @param {Number} length - number of random base-36 digits desired. Increase for more random strings.
* @param {String} namespace - name of plugin to be incorporated in uid, optional.
* @default {String} '' - if no plugin name is provided, nothing is appended to the uid.
* @returns {String} - unique id
*/
function GetYoDigits() {
var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 6;
var namespace = arguments.length > 1 ? arguments[1] : undefined;
var str = '';
var chars = '0123456789abcdefghijklmnopqrstuvwxyz';
var charsLength = chars.length;
for (var i = 0; i < length; i++) {
str += chars[Math.floor(Math.random() * charsLength)];
}
return namespace ? "".concat(str, "-").concat(namespace) : str;
}
/**
* Escape a string so it can be used as a regexp pattern
* @function
* @see https://stackoverflow.com/a/9310752/4317384
*
* @param {String} str - string to escape.
* @returns {String} - escaped string
*/
function RegExpEscape(str) {
return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
}
function transitionend($elem) {
var transitions = {
'transition': 'transitionend',
'WebkitTransition': 'webkitTransitionEnd',
'MozTransition': 'transitionend',
'OTransition': 'otransitionend'
};
var elem = document.createElement('div'),
end;
for (var transition in transitions) {
if (typeof elem.style[transition] !== 'undefined') {
end = transitions[transition];
}
}
if (end) {
return end;
} else {
setTimeout(function () {
$elem.triggerHandler('transitionend', [$elem]);
}, 1);
return 'transitionend';
}
}
/**
* Return an event type to listen for window load.
*
* If `$elem` is passed, an event will be triggered on `$elem`. If window is already loaded, the event will still be triggered.
* If `handler` is passed, attach it to the event on `$elem`.
* Calling `onLoad` without handler allows you to get the event type that will be triggered before attaching the handler by yourself.
* @function
*
* @param {Object} [] $elem - jQuery element on which the event will be triggered if passed.
* @param {Function} [] handler - function to attach to the event.
* @returns {String} - event type that should or will be triggered.
*/
function onLoad($elem, handler) {
var didLoad = document.readyState === 'complete';
var eventType = (didLoad ? '_didLoad' : 'load') + '.zf.util.onLoad';
var cb = function cb() {
return $elem.triggerHandler(eventType);
};
if ($elem) {
if (handler) $elem.one(eventType, handler);
if (didLoad) setTimeout(cb);else jquery__WEBPACK_IMPORTED_MODULE_0___default()(window).one('load', cb);
}
return eventType;
}
/**
* Retuns an handler for the `mouseleave` that ignore disappeared mouses.
*
* If the mouse "disappeared" from the document (like when going on a browser UI element, See https://git.io/zf-11410),
* the event is ignored.
* - If the `ignoreLeaveWindow` is `true`, the event is ignored when the user actually left the window
* (like by switching to an other window with [Alt]+[Tab]).
* - If the `ignoreReappear` is `true`, the event will be ignored when the mouse will reappear later on the document
* outside of the element it left.
*
* @function
*
* @param {Function} [] handler - handler for the filtered `mouseleave` event to watch.
* @param {Object} [] options - object of options:
* - {Boolean} [false] ignoreLeaveWindow - also ignore when the user switched windows.
* - {Boolean} [false] ignoreReappear - also ignore when the mouse reappeared outside of the element it left.
* @returns {Function} - filtered handler to use to listen on the `mouseleave` event.
*/
function ignoreMousedisappear(handler) {
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
_ref$ignoreLeaveWindo = _ref.ignoreLeaveWindow,
ignoreLeaveWindow = _ref$ignoreLeaveWindo === void 0 ? false : _ref$ignoreLeaveWindo,
_ref$ignoreReappear = _ref.ignoreReappear,
ignoreReappear = _ref$ignoreReappear === void 0 ? false : _ref$ignoreReappear;
return function leaveEventHandler(eLeave) {
for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
rest[_key - 1] = arguments[_key];
}
var callback = handler.bind.apply(handler, [this, eLeave].concat(rest)); // The mouse left: call the given callback if the mouse entered elsewhere
if (eLeave.relatedTarget !== null) {
return callback();
} // Otherwise, check if the mouse actually left the window.
// In firefox if the user switched between windows, the window sill have the focus by the time
// the event is triggered. We have to debounce the event to test this case.
setTimeout(function leaveEventDebouncer() {
if (!ignoreLeaveWindow && document.hasFocus && !document.hasFocus()) {
return callback();
} // Otherwise, wait for the mouse to reeapear outside of the element,
if (!ignoreReappear) {
jquery__WEBPACK_IMPORTED_MODULE_0___default()(document).one('mouseenter', function reenterEventHandler(eReenter) {
if (!jquery__WEBPACK_IMPORTED_MODULE_0___default()(eLeave.currentTarget).has(eReenter.target).length) {
// Fill where the mouse finally entered.
eLeave.relatedTarget = eReenter.target;
callback();
}
});
}
}, 0);
};
}
var foundation_core_utils = /*#__PURE__*/Object.freeze({
__proto__: null,
rtl: rtl,
GetYoDigits: GetYoDigits,
RegExpEscape: RegExpEscape,
transitionend: transitionend,
onLoad: onLoad,
ignoreMousedisappear: ignoreMousedisappear
});
// const defaultQueries = {
// 'default' : 'only screen',
// landscape : 'only screen and (orientation: landscape)',
// portrait : 'only screen and (orientation: portrait)',
// retina : 'only screen and (-webkit-min-device-pixel-ratio: 2),' +
// 'only screen and (min--moz-device-pixel-ratio: 2),' +
// 'only screen and (-o-min-device-pixel-ratio: 2/1),' +
// 'only screen and (min-device-pixel-ratio: 2),' +
// 'only screen and (min-resolution: 192dpi),' +
// 'only screen and (min-resolution: 2dppx)'
// };
// matchMedia() polyfill - Test a CSS media type/query in JS.
// Authors & copyright © 2012: Scott Jehl, Paul Irish, Nicholas Zakas, David Knight. MIT license
/* eslint-disable */
window.matchMedia || (window.matchMedia = function () {
var styleMedia = window.styleMedia || window.media; // For those that don't support matchMedium
if (!styleMedia) {
var style = document.createElement('style'),
script = document.getElementsByTagName('script')[0],
info = null;
style.type = 'text/css';
style.id = 'matchmediajs-test';
if (!script) {
document.head.appendChild(style);
} else {
script.parentNode.insertBefore(style, script);
} // 'style.currentStyle' is used by IE <= 8 and 'window.getComputedStyle' for all other browsers
info = 'getComputedStyle' in window && window.getComputedStyle(style, null) || style.currentStyle;
styleMedia = {
matchMedium: function matchMedium(media) {
var text = '@media ' + media + '{ #matchmediajs-test { width: 1px; } }'; // 'style.styleSheet' is used by IE <= 8 and 'style.textContent' for all other browsers
if (style.styleSheet) {
style.styleSheet.cssText = text;
} else {
style.textContent = text;
} // Test if media query is true or false
return info.width === '1px';
}
};
}
return function (media) {
return {
matches: styleMedia.matchMedium(media || 'all'),
media: media || 'all'
};
};
}());
/* eslint-enable */
var MediaQuery = {
queries: [],
current: '',
/**
* Initializes the media query helper, by extracting the breakpoint list from the CSS and activating the breakpoint watcher.
* @function
* @private
*/
_init: function _init() {
// make sure the initialization is only done once when calling _init() several times
if (this.isInitialized === true) {
return this;
} else {
this.isInitialized = true;
}
var self = this;
var $meta = jquery__WEBPACK_IMPORTED_MODULE_0___default()('meta.foundation-mq');
if (!$meta.length) {
jquery__WEBPACK_IMPORTED_MODULE_0___default()('<meta class="foundation-mq" name="foundation-mq" content>').appendTo(document.head);
}
var extractedStyles = jquery__WEBPACK_IMPORTED_MODULE_0___default()('.foundation-mq').css('font-family');
var namedQueries;
namedQueries = parseStyleToObject(extractedStyles);
self.queries = []; // reset
for (var key in namedQueries) {
if (namedQueries.hasOwnProperty(key)) {
self.queries.push({
name: key,
value: "only screen and (min-width: ".concat(namedQueries[key], ")")
});
}
}
this.current = this._getCurrentSize();
this._watcher();
},
/**
* Reinitializes the media query helper.
* Useful if your CSS breakpoint configuration has just been loaded or has changed since the initialization.
* @function
* @private
*/
_reInit: function _reInit() {
this.isInitialized = false;
this._init();
},
/**
* Checks if the screen is at least as wide as a breakpoint.
* @function
* @param {String} size - Name of the breakpoint to check.
* @returns {Boolean} `true` if the breakpoint matches, `false` if it's smaller.
*/
atLeast: function atLeast(size) {
var query = this.get(size);
if (query) {
return window.matchMedia(query).matches;
}
return false;
},
/**
* Checks if the screen is within the given breakpoint.
* If smaller than the breakpoint of larger than its upper limit it returns false.
* @function
* @param {String} size - Name of the breakpoint to check.
* @returns {Boolean} `true` if the breakpoint matches, `false` otherwise.
*/
only: function only(size) {
return size === this._getCurrentSize();
},
/**
* Checks if the screen is within a breakpoint or smaller.
* @function
* @param {String} size - Name of the breakpoint to check.
* @returns {Boolean} `true` if the breakpoint matches, `false` if it's larger.
*/
upTo: function upTo(size) {
var nextSize = this.next(size); // If the next breakpoint does not match, the screen is smaller than
// the upper limit of this breakpoint.
if (nextSize) {
return !this.atLeast(nextSize);
} // If there is no next breakpoint, the "size" breakpoint does not have
// an upper limit and the screen will always be within it or smaller.
return true;
},
/**
* Checks if the screen matches to a breakpoint.
* @function
* @param {String} size - Name of the breakpoint to check, either 'small only' or 'small'. Omitting 'only' falls back to using atLeast() method.
* @returns {Boolean} `true` if the breakpoint matches, `false` if it does not.
*/
is: function is(size) {
var parts = size.trim().split(' ').filter(function (p) {
return !!p.length;
});
var _parts = _slicedToArray(parts, 2),
bpSize = _parts[0],
_parts$ = _parts[1],
bpModifier = _parts$ === void 0 ? '' : _parts$; // Only the breakpont
if (bpModifier === 'only') {
return this.only(bpSize);
} // At least the breakpoint (included)
if (!bpModifier || bpModifier === 'up') {
return this.atLeast(bpSize);
} // Up to the breakpoint (included)
if (bpModifier === 'down') {
return this.upTo(bpSize);
}
throw new Error("\n Invalid breakpoint passed to MediaQuery.is().\n Expected a breakpoint name formatted like \"<size> <modifier>\", got \"".concat(size, "\".\n "));
},
/**
* Gets the media query of a breakpoint.
* @function
* @param {String} size - Name of the breakpoint to get.
* @returns {String|null} - The media query of the breakpoint, or `null` if the breakpoint doesn't exist.
*/
get: function get(size) {
for (var i in this.queries) {
if (this.queries.hasOwnProperty(i)) {
var query = this.queries[i];
if (size === query.name) return query.value;
}
}
return null;
},
/**
* Get the breakpoint following the given breakpoint.
* @function
* @param {String} size - Name of the breakpoint.
* @returns {String|null} - The name of the following breakpoint, or `null` if the passed breakpoint was the last one.
*/
next: function next(size) {
var _this = this;
var queryIndex = this.queries.findIndex(function (q) {
return _this._getQueryName(q) === size;
});
if (queryIndex === -1) {
throw new Error("\n Unknown breakpoint \"".concat(size, "\" passed to MediaQuery.next().\n Ensure it is present in your Sass \"$breakpoints\" setting.\n "));
}
var nextQuery = this.queries[queryIndex + 1];
return nextQuery ? nextQuery.name : null;
},
/**
* Returns the name of the breakpoint related to the given value.
* @function
* @private
* @param {String|Object} value - Breakpoint name or query object.
* @returns {String} Name of the breakpoint.
*/
_getQueryName: function _getQueryName(value) {
if (typeof value === 'string') return value;
if (_typeof(value) === 'object') return value.name;
throw new TypeError("\n Invalid value passed to MediaQuery._getQueryName().\n Expected a breakpoint name (String) or a breakpoint query (Object), got \"".concat(value, "\" (").concat(_typeof(value), ")\n "));
},
/**
* Gets the current breakpoint name by testing every breakpoint and returning the last one to match (the biggest one).
* @function
* @private
* @returns {String} Name of the current breakpoint.
*/
_getCurrentSize: function _getCurrentSize() {
var matched;
for (var i = 0; i < this.queries.length; i++) {
var query = this.queries[i];
if (window.matchMedia(query.value).matches) {
matched = query;
}
}
return matched && this._getQueryName(matched);
},
/**
* Activates the breakpoint watcher, which fires an event on the window whenever the breakpoint changes.
* @function
* @private
*/
_watcher: function _watcher() {
var _this2 = this;
jquery__WEBPACK_IMPORTED_MODULE_0___default()(window).on('resize.zf.trigger', function () {
var newSize = _this2._getCurrentSize(),
currentSize = _this2.current;
if (newSize !== currentSize) {
// Change the current media query
_this2.current = newSize; // Broadcast the media query change on the window
jquery__WEBPACK_IMPORTED_MODULE_0___default()(window).trigger('changed.zf.mediaquery', [newSize, currentSize]);
}
});
}
}; // Thank you: https://github.com/sindresorhus/query-string
function parseStyleToObject(str) {
var styleObject = {};
if (typeof str !== 'string') {
return styleObject;
}
str = str.trim().slice(1, -1); // browsers re-quote string style values
if (!str) {
return styleObject;
}
styleObject = str.split('&').reduce(function (ret, param) {
var parts = param.replace(/\+/g, ' ').split('=');
var key = parts[0];
var val = parts[1];
key = decodeURIComponent(key); // missing `=` should be `null`:
// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
val = typeof val === 'undefined' ? null : decodeURIComponent(val);
if (!ret.hasOwnProperty(key)) {
ret[key] = val;
} else if (Array.isArray(ret[key])) {
ret[key].push(val);
} else {
ret[key] = [ret[key], val];
}
return ret;
}, {});
return styleObject;
}
var FOUNDATION_VERSION = '6.7.5'; // Global Foundation object
// This is attached to the window, or used as a module for AMD/Browserify
var Foundation = {
version: FOUNDATION_VERSION,
/**
* Stores initialized plugins.
*/
_plugins: {},
/**
* Stores generated unique ids for plugin instances
*/
_uuids: [],
/**
* Defines a Foundation plugin, adding it to the `Foundation` namespace and the list of plugins to initialize when reflowing.
* @param {Object} plugin - The constructor of the plugin.
*/
plugin: function plugin(_plugin, name) {
// Object key to use when adding to global Foundation object
// Examples: Foundation.Reveal, Foundation.OffCanvas
var className = name || functionName(_plugin); // Object key to use when storing the plugin, also used to create the identifying data attribute for the plugin
// Examples: data-reveal, data-off-canvas
var attrName = hyphenate(className); // Add to the Foundation object and the plugins list (for reflowing)
this._plugins[attrName] = this[className] = _plugin;
},
/**
* @function
* Populates the _uuids array with pointers to each individual plugin instance.
* Adds the `zfPlugin` data-attribute to programmatically created plugins to allow use of $(selector).foundation(method) calls.
* Also fires the initialization event for each plugin, consolidating repetitive code.
* @param {Object} plugin - an instance of a plugin, usually `this` in context.
* @param {String} name - the name of the plugin, passed as a camelCased string.
* @fires Plugin#init
*/
registerPlugin: function registerPlugin(plugin, name) {
var pluginName = name ? hyphenate(name) : functionName(plugin.constructor).toLowerCase();
plugin.uuid = GetYoDigits(6, pluginName);
if (!plugin.$element.attr("data-".concat(pluginName))) {
plugin.$element.attr("data-".concat(pluginName), plugin.uuid);
}
if (!plugin.$element.data('zfPlugin')) {
plugin.$element.data('zfPlugin', plugin);
}
/**
* Fires when the plugin has initialized.
* @event Plugin#init
*/
plugin.$element.trigger("init.zf.".concat(pluginName));
this._uuids.push(plugin.uuid);
return;
},
/**
* @function
* Removes the plugins uuid from the _uuids array.
* Removes the zfPlugin data attribute, as well as the data-plugin-name attribute.
* Also fires the destroyed event for the plugin, consolidating repetitive code.
* @param {Object} plugin - an instance of a plugin, usually `this` in context.
* @fires Plugin#destroyed
*/
unregisterPlugin: function unregisterPlugin(plugin) {
var pluginName = hyphenate(functionName(plugin.$element.data('zfPlugin').constructor));
this._uuids.splice(this._uuids.indexOf(plugin.uuid), 1);
plugin.$element.removeAttr("data-".concat(pluginName)).removeData('zfPlugin')
/**
* Fires when the plugin has been destroyed.
* @event Plugin#destroyed
*/.trigger("destroyed.zf.".concat(pluginName));
for (var prop in plugin) {
if (typeof plugin[prop] === 'function') {
plugin[prop] = null; //clean up script to prep for garbage collection.
}
}
return;
},
/**
* @function
* Causes one or more active plugins to re-initialize, resetting event listeners, recalculating positions, etc.
* @param {String} plugins - optional string of an individual plugin key, attained by calling `$(element).data('pluginName')`, or string of a plugin class i.e. `'dropdown'`
* @default If no argument is passed, reflow all currently active plugins.
*/
reInit: function reInit(plugins) {
var isJQ = plugins instanceof (jquery__WEBPACK_IMPORTED_MODULE_0___default());
try {
if (isJQ) {
plugins.each(function () {
jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).data('zfPlugin')._init();
});
} else {
var type = _typeof(plugins),
_this = this,
fns = {
'object': function object(plgs) {
plgs.forEach(function (p) {
p = hyphenate(p);
jquery__WEBPACK_IMPORTED_MODULE_0___default()('[data-' + p + ']').foundation('_init');
});
},
'string': function string() {
plugins = hyphenate(plugins);
jquery__WEBPACK_IMPORTED_MODULE_0___default()('[data-' + plugins + ']').foundation('_init');
},
'undefined': function undefined$1() {
this.object(Object.keys(_this._plugins));
}
};
fns[type](plugins);
}
} catch (err) {
console.error(err);
} finally {
return plugins;
}
},
/**
* Initialize plugins on any elements within `elem` (and `elem` itself) that aren't already initialized.
* @param {Object} elem - jQuery object containing the element to check inside. Also checks the element itself, unless it's the `document` object.
* @param {String|Array} plugins - A list of plugins to initialize. Leave this out to initialize everything.
*/
reflow: function reflow(elem, plugins) {
// If plugins is undefined, just grab everything
if (typeof plugins === 'undefined') {
plugins = Object.keys(this._plugins);
} // If plugins is a string, convert it to an array with one item
else if (typeof plugins === 'string') {
plugins = [plugins];
}
var _this = this; // Iterate through each plugin
jquery__WEBPACK_IMPORTED_MODULE_0___default().each(plugins, function (i, name) {
// Get the current plugin
var plugin = _this._plugins[name]; // Localize the search to all elements inside elem, as well as elem itself, unless elem === document
var $elem = jquery__WEBPACK_IMPORTED_MODULE_0___default()(elem).find('[data-' + name + ']').addBack('[data-' + name + ']').filter(function () {
return typeof jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).data("zfPlugin") === 'undefined';
}); // For each plugin found, initialize it
$elem.each(function () {
var $el = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this),
opts = {
reflow: true
};
if ($el.attr('data-options')) {
$el.attr('data-options').split(';').forEach(function (option) {
var opt = option.split(':').map(function (el) {
return el.trim();
});
if (opt[0]) opts[opt[0]] = parseValue(opt[1]);
});
}
try {
$el.data('zfPlugin', new plugin(jquery__WEBPACK_IMPORTED_MODULE_0___default()(this), opts));
} catch (er) {
console.error(er);
} finally {
return;
}
});
});
},
getFnName: functionName,
addToJquery: function addToJquery() {
// TODO: consider not making this a jQuery function
// TODO: need way to reflow vs. re-initialize
/**
* The Foundation jQuery method.
* @param {String|Array} method - An action to perform on the current jQuery object.
*/
var foundation = function foundation(method) {
var type = _typeof(method),
$noJS = jquery__WEBPACK_IMPORTED_MODULE_0___default()('.no-js');
if ($noJS.length) {
$noJS.removeClass('no-js');
}
if (type === 'undefined') {
//needs to initialize the Foundation object, or an individual plugin.
MediaQuery._init();
Foundation.reflow(this);
} else if (type === 'string') {
//an individual method to invoke on a plugin or group of plugins
var args = Array.prototype.slice.call(arguments, 1); //collect all the arguments, if necessary
var plugClass = this.data('zfPlugin'); //determine the class of plugin
if (typeof plugClass !== 'undefined' && typeof plugClass[method] !== 'undefined') {
//make sure both the class and method exist
if (this.length === 1) {
//if there's only one, call it directly.
plugClass[method].apply(plugClass, args);
} else {
this.each(function (i, el) {
//otherwise loop through the jQuery collection and invoke the method on each
plugClass[method].apply(jquery__WEBPACK_IMPORTED_MODULE_0___default()(el).data('zfPlugin'), args);
});
}
} else {
//error for no class or no method
throw new ReferenceError("We're sorry, '" + method + "' is not an available method for " + (plugClass ? functionName(plugClass) : 'this element') + '.');
}
} else {
//error for invalid argument type
throw new TypeError("We're sorry, ".concat(type, " is not a valid parameter. You must use a string representing the method you wish to invoke."));
}
return this;
};
(jquery__WEBPACK_IMPORTED_MODULE_0___default().fn).foundation = foundation;
return (jquery__WEBPACK_IMPORTED_MODULE_0___default());
}
};
Foundation.util = {
/**
* Function for applying a debounce effect to a function call.
* @function
* @param {Function} func - Function to be called at end of timeout.
* @param {Number} delay - Time in ms to delay the call of `func`.
* @returns function
*/
throttle: function throttle(func, delay) {
var timer = null;
return function () {
var context = this,
args = arguments;
if (timer === null) {
timer = setTimeout(function () {
func.apply(context, args);
timer = null;
}, delay);
}
};
}
};
window.Foundation = Foundation; // Polyfill for requestAnimationFrame
(function () {
if (!Date.now || !window.Date.now) window.Date.now = Date.now = function () {
return new Date().getTime();
};
var vendors = ['webkit', 'moz'];
for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {
var vp = vendors[i];
window.requestAnimationFrame = window[vp + 'RequestAnimationFrame'];
window.cancelAnimationFrame = window[vp + 'CancelAnimationFrame'] || window[vp + 'CancelRequestAnimationFrame'];
}
if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent) || !window.requestAnimationFrame || !window.cancelAnimationFrame) {
var lastTime = 0;
window.requestAnimationFrame = function (callback) {
var now = Date.now();
var nextTime = Math.max(lastTime + 16, now);
return setTimeout(function () {
callback(lastTime = nextTime);
}, nextTime - now);
};
window.cancelAnimationFrame = clearTimeout;
}
/**
* Polyfill for performance.now, required by rAF
*/
if (!window.performance || !window.performance.now) {
window.performance = {
start: Date.now(),
now: function now() {
return Date.now() - this.start;
}
};
}
})();
if (!Function.prototype.bind) {
/* eslint-disable no-extend-native */
Function.prototype.bind = function (oThis) {
if (typeof this !== 'function') {
// closest thing possible to the ECMAScript 5
// internal IsCallable function
throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
}
var aArgs = Array.prototype.slice.call(arguments, 1),
fToBind = this,
fNOP = function fNOP() {},
fBound = function fBound() {
return fToBind.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments)));
};
if (this.prototype) {
// native functions don't have a prototype
fNOP.prototype = this.prototype;
}
fBound.prototype = new fNOP();
return fBound;
};
} // Polyfill to get the name of a function in IE9
function functionName(fn) {
if (typeof Function.prototype.name === 'undefined') {
var funcNameRegex = /function\s([^(]{1,})\(/;
var results = funcNameRegex.exec(fn.toString());
return results && results.length > 1 ? results[1].trim() : "";
} else if (typeof fn.prototype === 'undefined') {
return fn.constructor.name;
} else {
return fn.prototype.constructor.name;
}
}
function parseValue(str) {
if ('true' === str) return true;else if ('false' === str) return false;else if (!isNaN(str * 1)) return parseFloat(str);
return str;
} // Convert PascalCase to kebab-case
// Thank you: http://stackoverflow.com/a/8955580
function hyphenate(str) {
return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
}
var Box = {
ImNotTouchingYou: ImNotTouchingYou,
OverlapArea: OverlapArea,
GetDimensions: GetDimensions,
GetExplicitOffsets: GetExplicitOffsets
};
/**
* Compares the dimensions of an element to a container and determines collision events with container.
* @function
* @param {jQuery} element - jQuery object to test for collisions.
* @param {jQuery} parent - jQuery object to use as bounding container.
* @param {Boolean} lrOnly - set to true to check left and right values only.
* @param {Boolean} tbOnly - set to true to check top and bottom values only.
* @default if no parent object passed, detects collisions with `window`.
* @returns {Boolean} - true if collision free, false if a collision in any direction.
*/
function ImNotTouchingYou(element, parent, lrOnly, tbOnly, ignoreBottom) {
return OverlapArea(element, parent, lrOnly, tbOnly, ignoreBottom) === 0;
}
function OverlapArea(element, parent, lrOnly, tbOnly, ignoreBottom) {
var eleDims = GetDimensions(element),
topOver,
bottomOver,
leftOver,
rightOver;
if (parent) {
var parDims = GetDimensions(parent);
bottomOver = parDims.height + parDims.offset.top - (eleDims.offset.top + eleDims.height);
topOver = eleDims.offset.top - parDims.offset.top;
leftOver = eleDims.offset.left - parDims.offset.left;
rightOver = parDims.width + parDims.offset.left - (eleDims.offset.left + eleDims.width);
} else {
bottomOver = eleDims.windowDims.height + eleDims.windowDims.offset.top - (eleDims.offset.top + eleDims.height);
topOver = eleDims.offset.top - eleDims.windowDims.offset.top;
leftOver = eleDims.offset.left - eleDims.windowDims.offset.left;
rightOver = eleDims.windowDims.width - (eleDims.offset.left + eleDims.width);
}
bottomOver = ignoreBottom ? 0 : Math.min(bottomOver, 0);
topOver = Math.min(topOver, 0);
leftOver = Math.min(leftOver, 0);
rightOver = Math.min(rightOver, 0);
if (lrOnly) {
return leftOver + rightOver;
}
if (tbOnly) {
return topOver + bottomOver;
} // use sum of squares b/c we care about overlap area.
return Math.sqrt(topOver * topOver + bottomOver * bottomOver + leftOver * leftOver + rightOver * rightOver);
}
/**
* Uses native methods to return an object of dimension values.
* @function
* @param {jQuery || HTML} element - jQuery object or DOM element for which to get the dimensions. Can be any element other that document or window.
* @returns {Object} - nested object of integer pixel values
* TODO - if element is window, return only those values.
*/
function GetDimensions(elem) {
elem = elem.length ? elem[0] : elem;
if (elem === window || elem === document) {
throw new Error("I'm sorry, Dave. I'm afraid I can't do that.");
}
var rect = elem.getBoundingClientRect(),
parRect = elem.parentNode.getBoundingClientRect(),
winRect = document.body.getBoundingClientRect(),
winY = window.pageYOffset,
winX = window.pageXOffset;
return {
width: rect.width,
height: rect.height,
offset: {
top: rect.top + winY,
left: rect.left + winX
},
parentDims: {
width: parRect.width,
height: parRect.height,
offset: {
top: parRect.top + winY,
left: parRect.left + winX
}
},
windowDims: {
width: winRect.width,
height: winRect.height,
offset: {
top: winY,
left: winX
}
}
};
}
/**
* Returns an object of top and left integer pixel values for dynamically rendered elements,
* such as: Tooltip, Reveal, and Dropdown. Maintained for backwards compatibility, and where
* you don't know alignment, but generally from
* 6.4 forward you should use GetExplicitOffsets, as GetOffsets conflates position and alignment.
* @function
* @param {jQuery} element - jQuery object for the element being positioned.
* @param {jQuery} anchor - jQuery object for the element's anchor point.
* @param {String} position - a string relating to the desired position of the element, relative to it's anchor
* @param {Number} vOffset - integer pixel value of desired vertical separation between anchor and element.
* @param {Number} hOffset - integer pixel value of desired horizontal separation between anchor and element.
* @param {Boolean} isOverflow - if a collision event is detected, sets to true to default the element to full width - any desired offset.
* TODO alter/rewrite to work with `em` values as well/instead of pixels
*/
function GetExplicitOffsets(element, anchor, position, alignment, vOffset, hOffset, isOverflow) {
var $eleDims = GetDimensions(element),
$anchorDims = anchor ? GetDimensions(anchor) : null;
var topVal, leftVal;
if ($anchorDims !== null) {
// set position related attribute
switch (position) {
case 'top':
topVal = $anchorDims.offset.top - ($eleDims.height + vOffset);
break;
case 'bottom':
topVal = $anchorDims.offset.top + $anchorDims.height + vOffset;
break;
case 'left':
leftVal = $anchorDims.offset.left - ($eleDims.width + hOffset);
break;
case 'right':
leftVal = $anchorDims.offset.left + $anchorDims.width + hOffset;
break;
} // set alignment related attribute
switch (position) {
case 'top':
case 'bottom':
switch (alignment) {
case 'left':
leftVal = $anchorDims.offset.left + hOffset;
break;
case 'right':
leftVal = $anchorDims.offset.left - $eleDims.width + $anchorDims.width - hOffset;
break;
case 'center':
leftVal = isOverflow ? hOffset : $anchorDims.offset.left + $anchorDims.width / 2 - $eleDims.width / 2 + hOffset;
break;
}
break;
case 'right':
case 'left':
switch (alignment) {
case 'bottom':
topVal = $anchorDims.offset.top - vOffset + $anchorDims.height - $eleDims.height;
break;
case 'top':
topVal = $anchorDims.offset.top + vOffset;
break;
case 'center':
topVal = $anchorDims.offset.top + vOffset + $anchorDims.height / 2 - $eleDims.height / 2;
break;
}
break;
}
}
return {
top: topVal,
left: leftVal
};
}
/**
* Runs a callback function when images are fully loaded.
* @param {Object} images - Image(s) to check if loaded.
* @param {Func} callback - Function to execute when image is fully loaded.
*/
function onImagesLoaded(images, callback) {
var unloaded = images.length;
if (unloaded === 0) {
callback();
}
images.each(function () {
// Check if image is loaded
if (this.complete && typeof this.naturalWidth !== 'undefined') {
singleImageLoaded();
} else {
// If the above check failed, simulate loading on detached element.
var image = new Image(); // Still count image as loaded if it finalizes with an error.
var events = "load.zf.images error.zf.images";
jquery__WEBPACK_IMPORTED_MODULE_0___default()(image).one(events, function me() {
// Unbind the event listeners. We're using 'one' but only one of the two events will have fired.
jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).off(events, me);
singleImageLoaded();
});
image.src = jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).attr('src');
}
});
function singleImageLoaded() {
unloaded--;
if (unloaded === 0) {
callback();
}
}
}
/*******************************************
* *
* This util was created by Marius Olbertz *
* Please thank Marius on GitHub /owlbertz *
* or the web http://www.mariusolbertz.de/ *
* *
******************************************/
var keyCodes = {
9: 'TAB',
13: 'ENTER',
27: 'ESCAPE',
32: 'SPACE',
35: 'END',
36: 'HOME',
37: 'ARROW_LEFT',
38: 'ARROW_UP',
39: 'ARROW_RIGHT',
40: 'ARROW_DOWN'
};
var commands = {}; // Functions pulled out to be referenceable from internals
function findFocusable($element) {
if (!$element) {
return false;
}
return $element.find('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, *[tabindex], *[contenteditable]').filter(function () {
if (!jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).is(':visible') || jquery__WEBPACK_IMPORTED_MODULE_0___default()(this).attr('tabindex') < 0) {
return false;
} //only have visible elements and those that have a tabindex greater or equal 0
return true;
}).sort(function (a, b) {
if (jquery__WEBPACK_IMPORTED_MODULE_0___default()(a).attr('tabindex') === jquery__WEBPACK_IMPORTED_MODULE_0___default()(b).attr('tabindex')) {
return 0;
}
var aTabIndex = parseInt(jquery__WEBPACK_IMPORTED_MODULE_0___default()(a).attr('tabindex'), 10),
bTabIndex = parseInt(jquery__WEBPACK_IMPORTED_MODULE_0___default()(b).attr('tabindex'), 10); // Undefined is treated the same as 0
if (typeof jquery__WEBPACK_IMPORTED_MODULE_0___default()(a).attr('tabindex') === 'undefined' && bTabIndex > 0) {
return 1;
}
if (typeof jquery__WEBPACK_IMPORTED_MODULE_0___default()(b).attr('tabindex') === 'undefined' && aTabIndex > 0) {
return -1;
}
if (aTabIndex === 0 && bTabIndex > 0) {
return 1;
}
if (bTabIndex === 0 && aTabIndex > 0) {
return -1;
}
if (aTabIndex < bTabIndex) {
return -1;
}
if (aTabIndex > bTabIndex) {
return 1;
}
});
}
function parseKey(event) {
var key = keyCodes[event.which || event.keyCode] || String.fromCharCode(event.which).toUpperCase(); // Remove un-printable characters, e.g. for `fromCharCode` calls for CTRL only events
key = key.replace(/\W+/, '');
if (event.shiftKey) key = "SHIFT_".concat(key);
if (event.ctrlKey) key = "CTRL_".concat(key);
if (event.altKey) key = "ALT_".concat(key); // Remove trailing underscore, in case only modifiers were used (e.g. only `CTRL_ALT`)
key = key.replace(/_$/, '');
return key;
}
var Keyboard = {
keys: getKeyCodes(keyCodes),
/**
* Parses the (keyboard) event and returns a String that represents its key
* Can be used like Foundation.parseKey(event) === Foundation.keys.SPACE
* @param {Event} event - the event generated by the event handler
* @return String key - String that represents the key pressed
*/
parseKey: parseKey,
/**
* Handles the given (keyboard) event
* @param {Event} event - the event generated by the event handler
* @param {String} component - Foundation component's name, e.g. Slider or Reveal
* @param {Objects} functions - collection of functions that are to be executed
*/
handleKey: function handleKey(event, component, functions) {
var commandList = commands[component],
keyCode = this.parseKey(event),
cmds,
command,
fn;
if (!commandList) return console.warn('Component not defined!'); // Ignore the event if it was already handled
if (event.zfIsKeyHandled === true) return; // This component does not differentiate between ltr and rtl
if (typeof commandList.ltr === 'undefined') {
cmds = commandList; // use plain list
} else {
// merge ltr and rtl: if document is rtl, rtl overwrites ltr and vice versa
if (rtl()) cmds = jquery__WEBPACK_IMPORTED_MODULE_0___default().extend({}, commandList.ltr, commandList.rtl);else cmds = jquery__WEBPACK_IMPORTED_MODULE_0___default().extend({}, commandList.rtl, commandList.ltr);
}
command = cmds[keyCode];
fn = functions[command]; // Execute the handler if found
if (fn && typeof fn === 'function') {
var returnValue = fn.apply(); // Mark the event as "handled" to prevent future handlings
event.zfIsKeyHandled = true; // Execute function when event was handled
if (functions.handled || typeof functions.handled === 'function') {
functions.handled(returnV