@erst-vg/dkfds-vite 8.0.1

package/src/js/dkfds.js

@@ -0,0 +1,186 @@
+'use strict';
+import Accordion from './components/accordion';
+import Alert from './components/alert';
+import CheckboxToggleContent from './components/checkbox-toggle-content';
+import Dropdown from './components/dropdown';
+import DropdownSort from './components/dropdown-sort';
+import ErrorSummary from './components/error-summary';
+import InputRegexMask from './components/regex-input-mask';
+import Modal from './components/modal';
+import Navigation from './components/navigation';
+import RadioToggleGroup from './components/radio-toggle-content';
+import ResponsiveTable from './components/table';
+import Tabnav from  './components/tabnav';
+import TableSelectableRows from './components/selectable-table';
+import Toast from './components/toast';
+import Tooltip from './components/tooltip';
+const datePicker = require('./components/date-picker');
+/**
+ * The 'polyfills' define key ECMAScript 5 methods that may be missing from
+ * older browsers, so must be loaded first.
+ */
+require('./polyfills');
+
+/**
+ * Init all components
+ * @param {JSON} options {scope: HTMLElement} - Init all components within scope (default is document)
+ */
+var init = function (options) {
+  // Set the options to an empty object by default if no options are passed.
+  options = typeof options !== 'undefined' ? options : {}
+
+  // Allow the user to initialise FDS in only certain sections of the page
+  // Defaults to the entire document if nothing is set.
+  var scope = typeof options.scope !== 'undefined' ? options.scope : document
+
+  /*
+  ---------------------
+  Accordions
+  ---------------------
+  */
+  const jsSelectorAccordion = scope.getElementsByClassName('accordion');
+  for(let c = 0; c < jsSelectorAccordion.length; c++){
+    new Accordion(jsSelectorAccordion[ c ]).init();
+  }
+  const jsSelectorAccordionBordered = scope.querySelectorAll('.accordion-bordered:not(.accordion)');
+  for(let c = 0; c < jsSelectorAccordionBordered.length; c++){
+    new Accordion(jsSelectorAccordionBordered[ c ]).init();
+  }
+
+  /*
+  ---------------------
+  Alerts
+  ---------------------
+  */
+
+  const alertsWithCloseButton = scope.querySelectorAll('.alert.has-close');
+  for(let c = 0; c < alertsWithCloseButton.length; c++){
+    new Alert(alertsWithCloseButton[ c ]).init();
+  }
+  
+  /*
+  ---------------------
+  Checkbox collapse
+  ---------------------
+  */
+  const jsSelectorCheckboxCollapse = scope.getElementsByClassName('js-checkbox-toggle-content');
+  for(let c = 0; c < jsSelectorCheckboxCollapse.length; c++){
+    new CheckboxToggleContent(jsSelectorCheckboxCollapse[ c ]).init();
+  }
+
+  /*
+  ---------------------
+  Overflow menu
+  ---------------------
+  */
+  const jsSelectorDropdown = scope.getElementsByClassName('js-dropdown');
+  for(let c = 0; c < jsSelectorDropdown.length; c++){
+    new Dropdown(jsSelectorDropdown[ c ]).init();
+  }
+
+  
+  /*
+  ---------------------
+  Overflow menu sort
+  ---------------------
+  */
+  const jsSelectorDropdownSort = scope.getElementsByClassName('overflow-menu--sort');
+  for(let c = 0; c < jsSelectorDropdownSort.length; c++){
+    new DropdownSort(jsSelectorDropdownSort[ c ]).init();
+  }
+
+  /*
+  ---------------------
+  Datepicker
+  ---------------------
+  */
+  datePicker.on(scope);
+  
+  /*
+  ---------------------
+  Error summary
+  ---------------------
+  */
+  var $errorSummary = scope.querySelector('[data-module="error-summary"]');
+  new ErrorSummary($errorSummary).init();
+
+  /*
+  ---------------------
+  Input Regex - used on date fields
+  ---------------------
+  */
+  const jsSelectorRegex = scope.querySelectorAll('input[data-input-regex]');
+  for(let c = 0; c < jsSelectorRegex.length; c++){
+    new InputRegexMask(jsSelectorRegex[ c ]);
+  }
+
+  /*
+  ---------------------
+  Modal
+  ---------------------
+  */
+  const modals = scope.querySelectorAll('.fds-modal');
+  for(let d = 0; d < modals.length; d++) {
+    new Modal(modals[d]).init();
+  }
+  
+  /*
+  ---------------------
+  Navigation
+  ---------------------
+  */
+  new Navigation().init();
+   
+  /*
+  ---------------------
+  Radiobutton group collapse
+  ---------------------
+  */
+  const jsSelectorRadioCollapse = scope.getElementsByClassName('js-radio-toggle-group');
+  for(let c = 0; c < jsSelectorRadioCollapse.length; c++){
+    new RadioToggleGroup(jsSelectorRadioCollapse[ c ]).init();
+  }
+
+  /*
+  ---------------------
+  Responsive tables
+  ---------------------
+  */
+  const jsSelectorTable = scope.querySelectorAll('table:not(.dataTable)');
+  for(let c = 0; c < jsSelectorTable.length; c++){
+    new ResponsiveTable(jsSelectorTable[ c ]);
+  }
+
+  /*
+  ---------------------
+  Selectable rows in table
+  ---------------------
+  */
+  const jsSelectableTable = scope.querySelectorAll('table.table--selectable');
+  for(let c = 0; c < jsSelectableTable.length; c++){
+    new TableSelectableRows(jsSelectableTable[ c ]).init();
+  }
+
+  /*
+  ---------------------
+  Tabnav
+  ---------------------
+  */
+  const jsSelectorTabnav = scope.getElementsByClassName('tabnav');
+  for(let c = 0; c < jsSelectorTabnav.length; c++){
+    new Tabnav(jsSelectorTabnav[ c ]).init();
+  }
+
+  /*
+  ---------------------
+  Tooltip
+  ---------------------
+  */
+  const jsSelectorTooltip = scope.getElementsByClassName('js-tooltip');
+  for(let c = 0; c < jsSelectorTooltip.length; c++){
+    new Tooltip(jsSelectorTooltip[ c ]).init();
+  }
+  
+};
+
+module.exports = { init, Accordion, Alert, CheckboxToggleContent, Dropdown, DropdownSort, datePicker, ErrorSummary, InputRegexMask, Modal, Navigation, RadioToggleGroup, ResponsiveTable, TableSelectableRows, Tabnav, Toast, Tooltip};

package/src/js/events.js

@@ -0,0 +1,15 @@
+module.exports = {
+  // This used to be conditionally dependent on whether the
+  // browser supported touch events; if it did, `CLICK` was set to
+  // `touchstart`.  However, this had downsides:
+  //
+  // * It pre-empted mobile browsers' default behavior of detecting
+  //   whether a touch turned into a scroll, thereby preventing
+  //   users from using some of our components as scroll surfaces.
+  //
+  // * Some devices, such as the Microsoft Surface Pro, support *both*
+  //   touch and clicks. This meant the conditional effectively dropped
+  //   support for the user's mouse, frustrating users who preferred
+  //   it on those systems.
+  CLICK: 'click',
+};

package/src/js/polyfills/Function/prototype/bind.js

@@ -0,0 +1,159 @@
+import '../../Object/defineProperty'
+
+(function(undefined) {
+  // Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Function/prototype/bind/detect.js
+  var detect = 'bind' in Function.prototype
+
+  if (detect) return
+
+  // Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Function.prototype.bind&flags=always
+  Object.defineProperty(Function.prototype, 'bind', {
+      value: function bind(that) { // .length is 1
+          // add necessary es5-shim utilities
+          var $Array = Array;
+          var $Object = Object;
+          var ObjectPrototype = $Object.prototype;
+          var ArrayPrototype = $Array.prototype;
+          var Empty = function Empty() {};
+          var to_string = ObjectPrototype.toString;
+          var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+          var isCallable; /* inlined from https://npmjs.com/is-callable */ var fnToStr = Function.prototype.toString, tryFunctionObject = function tryFunctionObject(value) { try { fnToStr.call(value); return true; } catch (e) { return false; } }, fnClass = '[object Function]', genClass = '[object GeneratorFunction]'; isCallable = function isCallable(value) { if (typeof value !== 'function') { return false; } if (hasToStringTag) { return tryFunctionObject(value); } var strClass = to_string.call(value); return strClass === fnClass || strClass === genClass; };
+          var array_slice = ArrayPrototype.slice;
+          var array_concat = ArrayPrototype.concat;
+          var array_push = ArrayPrototype.push;
+          var max = Math.max;
+          // /add necessary es5-shim utilities
+
+          // 1. Let Target be the this value.
+          var target = this;
+          // 2. If IsCallable(Target) is false, throw a TypeError exception.
+          if (!isCallable(target)) {
+              throw new TypeError('Function.prototype.bind called on incompatible ' + target);
+          }
+          // 3. Let A be a new (possibly empty) internal list of all of the
+          //   argument values provided after thisArg (arg1, arg2 etc), in order.
+          // XXX slicedArgs will stand in for "A" if used
+          var args = array_slice.call(arguments, 1); // for normal call
+          // 4. Let F be a new native ECMAScript object.
+          // 11. Set the [[Prototype]] internal property of F to the standard
+          //   built-in Function prototype object as specified in 15.3.3.1.
+          // 12. Set the [[Call]] internal property of F as described in
+          //   15.3.4.5.1.
+          // 13. Set the [[Construct]] internal property of F as described in
+          //   15.3.4.5.2.
+          // 14. Set the [[HasInstance]] internal property of F as described in
+          //   15.3.4.5.3.
+          var bound;
+          var binder = function () {
+
+              if (this instanceof bound) {
+                  // 15.3.4.5.2 [[Construct]]
+                  // When the [[Construct]] internal method of a function object,
+                  // F that was created using the bind function is called with a
+                  // list of arguments ExtraArgs, the following steps are taken:
+                  // 1. Let target be the value of F's [[TargetFunction]]
+                  //   internal property.
+                  // 2. If target has no [[Construct]] internal method, a
+                  //   TypeError exception is thrown.
+                  // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
+                  //   property.
+                  // 4. Let args be a new list containing the same values as the
+                  //   list boundArgs in the same order followed by the same
+                  //   values as the list ExtraArgs in the same order.
+                  // 5. Return the result of calling the [[Construct]] internal
+                  //   method of target providing args as the arguments.
+
+                  var result = target.apply(
+                      this,
+                      array_concat.call(args, array_slice.call(arguments))
+                  );
+                  if ($Object(result) === result) {
+                      return result;
+                  }
+                  return this;
+
+              } else {
+                  // 15.3.4.5.1 [[Call]]
+                  // When the [[Call]] internal method of a function object, F,
+                  // which was created using the bind function is called with a
+                  // this value and a list of arguments ExtraArgs, the following
+                  // steps are taken:
+                  // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
+                  //   property.
+                  // 2. Let boundThis be the value of F's [[BoundThis]] internal
+                  //   property.
+                  // 3. Let target be the value of F's [[TargetFunction]] internal
+                  //   property.
+                  // 4. Let args be a new list containing the same values as the
+                  //   list boundArgs in the same order followed by the same
+                  //   values as the list ExtraArgs in the same order.
+                  // 5. Return the result of calling the [[Call]] internal method
+                  //   of target providing boundThis as the this value and
+                  //   providing args as the arguments.
+
+                  // equiv: target.call(this, ...boundArgs, ...args)
+                  return target.apply(
+                      that,
+                      array_concat.call(args, array_slice.call(arguments))
+                  );
+
+              }
+
+          };
+
+          // 15. If the [[Class]] internal property of Target is "Function", then
+          //     a. Let L be the length property of Target minus the length of A.
+          //     b. Set the length own property of F to either 0 or L, whichever is
+          //       larger.
+          // 16. Else set the length own property of F to 0.
+
+          var boundLength = max(0, target.length - args.length);
+
+          // 17. Set the attributes of the length own property of F to the values
+          //   specified in 15.3.5.1.
+          var boundArgs = [];
+          for (var i = 0; i < boundLength; i++) {
+              array_push.call(boundArgs, '$' + i);
+          }
+
+          // XXX Build a dynamic function with desired amount of arguments is the only
+          // way to set the length property of a function.
+          // In environments where Content Security Policies enabled (Chrome extensions,
+          // for ex.) all use of eval or Function costructor throws an exception.
+          // However in all of these environments Function.prototype.bind exists
+          // and so this code will never be executed.
+          bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
+
+          if (target.prototype) {
+              Empty.prototype = target.prototype;
+              bound.prototype = new Empty();
+              // Clean up dangling references.
+              Empty.prototype = null;
+          }
+
+          // TODO
+          // 18. Set the [[Extensible]] internal property of F to true.
+
+          // TODO
+          // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
+          // 20. Call the [[DefineOwnProperty]] internal method of F with
+          //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
+          //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
+          //   false.
+          // 21. Call the [[DefineOwnProperty]] internal method of F with
+          //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
+          //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
+          //   and false.
+
+          // TODO
+          // NOTE Function objects created using Function.prototype.bind do not
+          // have a prototype property or the [[Code]], [[FormalParameters]], and
+          // [[Scope]] internal properties.
+          // XXX can't delete prototype in pure-js.
+
+          // 22. Return F.
+          return bound;
+      }
+  });
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});

package/src/js/polyfills/Object/defineProperty.js

@@ -0,0 +1,86 @@
+(function(undefined) {
+
+// Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Object/defineProperty/detect.js
+var detect = (
+  // In IE8, defineProperty could only act on DOM elements, so full support
+  // for the feature requires the ability to set a property on an arbitrary object
+  'defineProperty' in Object && (function() {
+  	try {
+  		var a = {};
+  		Object.defineProperty(a, 'test', {value:42});
+  		return true;
+  	} catch(e) {
+  		return false
+  	}
+  }())
+)
+
+if (detect) return
+
+// Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Object.defineProperty&flags=always
+(function (nativeDefineProperty) {
+
+	var supportsAccessors = Object.prototype.hasOwnProperty('__defineGetter__');
+	var ERR_ACCESSORS_NOT_SUPPORTED = 'Getters & setters cannot be defined on this javascript engine';
+	var ERR_VALUE_ACCESSORS = 'A property cannot both have accessors and be writable or have a value';
+
+	Object.defineProperty = function defineProperty(object, property, descriptor) {
+
+		// Where native support exists, assume it
+		if (nativeDefineProperty && (object === window || object === document || object === Element.prototype || object instanceof Element)) {
+			return nativeDefineProperty(object, property, descriptor);
+		}
+
+		if (object === null || !(object instanceof Object || typeof object === 'object')) {
+			throw new TypeError('Object.defineProperty called on non-object');
+		}
+
+		if (!(descriptor instanceof Object)) {
+			throw new TypeError('Property description must be an object');
+		}
+
+		var propertyString = String(property);
+		var hasValueOrWritable = 'value' in descriptor || 'writable' in descriptor;
+		var getterType = 'get' in descriptor && typeof descriptor.get;
+		var setterType = 'set' in descriptor && typeof descriptor.set;
+
+		// handle descriptor.get
+		if (getterType) {
+			if (getterType !== 'function') {
+				throw new TypeError('Getter must be a function');
+			}
+			if (!supportsAccessors) {
+				throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
+			}
+			if (hasValueOrWritable) {
+				throw new TypeError(ERR_VALUE_ACCESSORS);
+			}
+			Object.__defineGetter__.call(object, propertyString, descriptor.get);
+		} else {
+			object[propertyString] = descriptor.value;
+		}
+
+		// handle descriptor.set
+		if (setterType) {
+			if (setterType !== 'function') {
+				throw new TypeError('Setter must be a function');
+			}
+			if (!supportsAccessors) {
+				throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
+			}
+			if (hasValueOrWritable) {
+				throw new TypeError(ERR_VALUE_ACCESSORS);
+			}
+			Object.__defineSetter__.call(object, propertyString, descriptor.set);
+		}
+
+		// OK to define value unconditionally - if a getter has been specified as well, an error would be thrown above
+		if ('value' in descriptor) {
+			object[propertyString] = descriptor.value;
+		}
+
+		return object;
+	};
+}(Object.defineProperty));
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});

package/src/js/polyfills/custom-event.js

@@ -0,0 +1,23 @@
+/* eslint-disable consistent-return */
+/* eslint-disable func-names */
+(function () {
+  if (typeof window.CustomEvent === "function") return false;
+
+  function CustomEvent(event, _params) {
+    const params = _params || {
+      bubbles: false,
+      cancelable: false,
+      detail: null,
+    };
+    const evt = document.createEvent("CustomEvent");
+    evt.initCustomEvent(
+      event,
+      params.bubbles,
+      params.cancelable,
+      params.detail
+    );
+    return evt;
+  }
+
+  window.CustomEvent = CustomEvent;
+})();

package/src/js/polyfills/element-hidden.js

@@ -0,0 +1,18 @@
+'use strict';
+const elproto = window.HTMLElement.prototype;
+const HIDDEN = 'hidden';
+
+if (!(HIDDEN in elproto)) {
+  Object.defineProperty(elproto, HIDDEN, {
+    get: function () {
+      return this.hasAttribute(HIDDEN);
+    },
+    set: function (value) {
+      if (value) {
+        this.setAttribute(HIDDEN, '');
+      } else {
+        this.removeAttribute(HIDDEN);
+      }
+    },
+  });
+}

package/src/js/polyfills/index.js

@@ -0,0 +1,14 @@
+'use strict';
+// polyfills HTMLElement.prototype.classList and DOMTokenList
+require('classlist-polyfill');
+// polyfills HTMLElement.prototype.hidden
+require('./element-hidden');
+
+// polyfills Number.isNaN()
+require("./number-is-nan");
+
+// polyfills CustomEvent
+require("./custom-event");
+
+require('core-js/fn/object/assign');
+require('core-js/fn/array/from');

package/src/js/polyfills/number-is-nan.js

@@ -0,0 +1,6 @@
+Number.isNaN =
+  Number.isNaN ||
+  function isNaN(input) {
+    // eslint-disable-next-line no-self-compare
+    return typeof input === "number" && input !== input;
+  };

package/src/js/utils/active-element.js

@@ -0,0 +1 @@
+module.exports = (htmlDocument = document) => htmlDocument.activeElement;

package/src/js/utils/behavior.js

@@ -0,0 +1,36 @@
+const assign = require("object-assign");
+const receptor = require("receptor");
+
+/**
+ * @name sequence
+ * @param {...Function} seq an array of functions
+ * @return { closure } callHooks
+ */
+// We use a named function here because we want it to inherit its lexical scope
+// from the behavior props object, not from the module
+const sequence = (...seq) =>
+  function callHooks(target = document.body) {
+    seq.forEach((method) => {
+      if (typeof this[method] === "function") {
+        this[method].call(this, target);
+      }
+    });
+  };
+
+/**
+ * @name behavior
+ * @param {object} events
+ * @param {object?} props
+ * @return {receptor.behavior}
+ */
+module.exports = (events, props) =>
+  receptor.behavior(
+    events,
+    assign(
+      {
+        on: sequence("init", "add"),
+        off: sequence("teardown", "remove"),
+      },
+      props
+    )
+  );

package/src/js/utils/breakpoints.js

@@ -0,0 +1,10 @@
+'use strict';
+let breakpoints = {
+  'xs': 0,
+  'sm': 576,
+  'md': 768,
+  'lg': 992,
+  'xl': 1200
+};
+
+module.exports = breakpoints;

package/src/js/utils/closest.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * @name closest
+ * @desc get nearest parent element matching selector.
+ * @param {HTMLElement} el - The HTML element where the search starts.
+ * @param {string} selector - Selector to be found.
+ * @return {HTMLElement} - Nearest parent element matching selector.
+ */
+module.exports = function closest (el, selector) {
+  var matchesSelector = el.matches || el.webkitMatchesSelector || el.mozMatchesSelector || el.msMatchesSelector;
+
+  while (el) {
+      if (matchesSelector.call(el, selector)) {
+          break;
+      }
+      el = el.parentElement;
+  }
+  return el;
+};

package/src/js/utils/dispatch.js

@@ -0,0 +1,30 @@
+module.exports = (element, eventTypeString, listener, options) => {
+  const eventTypes = eventTypeString.split(/\s+/);
+
+  const add = () => {
+    eventTypes.forEach(type => {
+      element.addEventListener(type, listener, options);
+    });
+  };
+
+  const trigger = () => {
+    const type = eventTypes[ 0 ];
+    const event = document.createEvent('HTMLEvents');
+    event.initEvent(type, false, true);
+    element.dispatchEvent(event);
+  };
+
+  const remove = () => {
+    eventTypes.forEach(type => {
+      element.removeEventListener(type, listener, options);
+    });
+  };
+
+  add();
+
+  return {
+    on: add,
+    trigger: trigger,
+    off: remove,
+  };
+};

package/src/js/utils/generate-unique-id.js

@@ -0,0 +1,14 @@
+// Used to generate a unique string, allows multiple instances of the component without
+// Them conflicting with each other.
+// https://stackoverflow.com/a/8809472
+export function generateUniqueID () {
+  var d = new Date().getTime()
+  if (typeof window.performance !== 'undefined' && typeof window.performance.now === 'function') {
+    d += window.performance.now() // use high-precision timer if available
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = (d + Math.random() * 16) % 16 | 0
+    d = Math.floor(d / 16)
+    return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16)
+  })
+}

package/src/js/utils/is-in-viewport.js

@@ -0,0 +1,14 @@
+// https://stackoverflow.com/a/7557433
+function isElementInViewport (el, win=window,
+                              docEl=document.documentElement) {
+  var rect = el.getBoundingClientRect();
+
+  return (
+    rect.top >= 0 &&
+    rect.left >= 0 &&
+    rect.bottom <= (win.innerHeight || docEl.clientHeight) &&
+    rect.right <= (win.innerWidth || docEl.clientWidth)
+  );
+}
+
+module.exports = isElementInViewport;

package/src/js/utils/is-ios-device.js

@@ -0,0 +1,11 @@
+// iOS detection from: http://stackoverflow.com/a/9039885/177710
+function isIosDevice() {
+  return (
+    typeof navigator !== "undefined" &&
+    (navigator.userAgent.match(/(iPod|iPhone|iPad)/g) ||
+      (navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1)) &&
+    !window.MSStream
+  );
+}
+
+module.exports = isIosDevice;