use-mask-input 1.0.1 → 2.0.0

package/node_modules/inputmask/lib/canUseDOM.js

@@ -0,0 +1,7 @@
+const canUseDOM = !!(
+  typeof window !== "undefined" &&
+  window.document &&
+  window.document.createElement
+);
+
+export default canUseDOM;

package/node_modules/inputmask/lib/defaults.js

@@ -0,0 +1,101 @@
+import keyCode from "./keycode.json";
+
+export default {
+	_maxTestPos: 500,
+	placeholder: "_",
+	optionalmarker: ["[", "]"],
+	quantifiermarker: ["{", "}"],
+	groupmarker: ["(", ")"],
+	alternatormarker: "|",
+	escapeChar: "\\",
+	mask: null, //needs tobe null instead of undefined as the extend method does not consider props with the undefined value
+	regex: null, //regular expression as a mask
+	oncomplete: () => {
+	}, //executes when the mask is complete
+	onincomplete: () => {
+	}, //executes when the mask is incomplete and focus is lost
+	oncleared: () => {
+	}, //executes when the mask is cleared
+	repeat: 0, //repetitions of the mask: * ~ forever, otherwise specify an integer
+	greedy: false, //true: allocated buffer for the mask and repetitions - false: allocate only if needed
+	autoUnmask: false, //automatically unmask when retrieving the value with $.fn.val or value if the browser supports __lookupGetter__ or getOwnPropertyDescriptor
+	removeMaskOnSubmit: false, //remove the mask before submitting the form.
+	clearMaskOnLostFocus: true,
+	insertMode: true, //insert the input or overwrite the input
+	insertModeVisual: true, //show selected caret when insertmode = false
+	clearIncomplete: false, //clear the incomplete input on blur
+	alias: null,
+	onKeyDown: () => {
+	}, //callback to implement autocomplete on certain keys for example. args => event, buffer, caretPos, opts
+	onBeforeMask: null, //executes before masking the initial value to allow preprocessing of the initial value.	args => initialValue, opts => return processedValue
+	onBeforePaste: function (pastedValue, opts) {
+		return typeof opts.onBeforeMask === "function" ? opts.onBeforeMask.call(this, pastedValue, opts) : pastedValue;
+	}, //executes before masking the pasted value to allow preprocessing of the pasted value.	args => pastedValue, opts => return processedValue
+	onBeforeWrite: null, //executes before writing to the masked element. args => event, opts
+	onUnMask: null, //executes after unmasking to allow postprocessing of the unmaskedvalue.	args => maskedValue, unmaskedValue, opts
+	showMaskOnFocus: true, //show the mask-placeholder when the input has focus
+	showMaskOnHover: true, //show the mask-placeholder when hovering the empty input
+	onKeyValidation: () => {
+	}, //executes on every key-press with the result of isValid. Params: key, result, opts
+	skipOptionalPartCharacter: " ", //a character which can be used to skip an optional part of a mask
+	numericInput: false, //numericInput input direction style (input shifts to the left while holding the caret position)
+	rightAlign: false, //align to the right
+	undoOnEscape: true, //pressing escape reverts the value to the value before focus
+	//numeric basic properties
+	radixPoint: "", //".", // | ","
+	_radixDance: false, //dance around the radixPoint
+	groupSeparator: "", //",", // | "."
+	//numeric basic properties
+	keepStatic: null, //try to keep the mask static while typing. Decisions to alter the mask will be posponed if possible
+	positionCaretOnTab: true, //when enabled the caret position is set after the latest valid position on TAB
+	tabThrough: false, //allows for tabbing through the different parts of the masked field
+	supportsInputType: ["text", "tel", "url", "password", "search"], //list with the supported input types
+	//specify keyCodes which should not be considered in the keypress event, otherwise the preventDefault will stop their default behavior especially in FF
+	ignorables: [
+		keyCode.BACKSPACE,
+		keyCode.TAB,
+		keyCode["PAUSE/BREAK"],
+		keyCode.ESCAPE,
+		keyCode.PAGE_UP,
+		keyCode.PAGE_DOWN,
+		keyCode.END,
+		keyCode.HOME,
+		keyCode.LEFT,
+		keyCode.UP,
+		keyCode.RIGHT,
+		keyCode.DOWN,
+		keyCode.INSERT,
+		keyCode.DELETE,
+		93,
+		112,
+		113,
+		114,
+		115,
+		116,
+		117,
+		118,
+		119,
+		120,
+		121,
+		122,
+		123,
+		0,
+		229
+	],
+	isComplete: null, //override for isComplete - args => buffer, opts - return true || false
+	preValidation: null, //hook to preValidate the input.  Usefull for validating regardless the definition.	args => buffer, pos, char, isSelection, opts, maskset, caretPos, strict => return true/false/command object
+	postValidation: null, //hook to postValidate the result from isValid.	Usefull for validating the entry as a whole.	args => buffer, pos, c, currentResult, opts, maskset, strict, fromCheckval => return true/false/json
+	staticDefinitionSymbol: undefined, //specify a definitionSymbol for static content, used to make matches for alternators
+	jitMasking: false, //just in time masking ~ only mask while typing, can n (number), true or false
+	nullable: true, //return nothing instead of the buffertemplate when the user hasn't entered anything.
+	inputEventOnly: false, //dev option - testing inputfallback behavior
+	noValuePatching: false, //disable value property patching
+	positionCaretOnClick: "lvp", //none, lvp (based on the last valid position (default), radixFocus (position caret to radixpoint on initial click), select (select the whole input), ignore (ignore the click and continue the mask)
+	casing: null, //mask-level casing. Options: null, "upper", "lower" or "title" or callback args => elem, test, pos, validPositions return charValue
+	inputmode: "text", //specify the inputmode
+	importDataAttributes: true, //import data-inputmask attributes
+	shiftPositions: true, //shift position of the mask entries on entry and deletion.
+	usePrototypeDefinitions: true, //use the default defined definitions from the prototype
+	validationEventTimeOut: 3000, //Time to show validation error on form submit
+	substitutes: {} //define character substitutes
+};

package/node_modules/inputmask/lib/definitions.js

@@ -0,0 +1,13 @@
+export default {
+	"9": { //\uFF11-\uFF19 #1606
+		validator: "[0-9\uFF10-\uFF19]",
+		definitionSymbol: "*"
+	},
+	"a": { //\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5 #76
+		validator: "[A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]",
+		definitionSymbol: "*"
+	},
+	"*": {
+		validator: "[0-9\uFF10-\uFF19A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]"
+	}
+};

package/node_modules/inputmask/lib/dependencyLibs/data.js

@@ -0,0 +1,8 @@
+export default function (owner, key, value) {
+	if (value === undefined) {
+		return owner.__data ? owner.__data[key] : null;
+	} else {
+		owner.__data = owner.__data || {};
+		owner.__data[key] = value;
+	}
+}

package/node_modules/inputmask/lib/dependencyLibs/events.js

@@ -0,0 +1,199 @@
+import extend from "./extend";
+import window from "../global/window";
+import DependencyLib from "./inputmask.dependencyLib";
+import canUseDOM from "../canUseDOM";
+
+export {on, off, trigger, Event};
+
+function isValidElement(elem) {
+	return elem instanceof Element;
+}
+
+let Event;
+if (typeof window.CustomEvent === "function") {
+	Event = window.CustomEvent;
+} else {
+	if (canUseDOM) {
+		Event = function (event, params) {
+			params = params || {bubbles: false, cancelable: false, detail: undefined};
+			var evt = document.createEvent("CustomEvent");
+			evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+			return evt;
+		};
+		Event.prototype = window.Event.prototype;
+	}
+}
+
+
+function on(events, handler) {
+	function addEvent(ev, namespace) {
+		//register domevent
+		if (elem.addEventListener) { // all browsers except IE before version 9
+			elem.addEventListener(ev, handler, false);
+		} else if (elem.attachEvent) { // IE before version 9
+			elem.attachEvent("on" + ev, handler);
+		}
+		eventRegistry[ev] = eventRegistry[ev] || {};
+		eventRegistry[ev][namespace] = eventRegistry[ev][namespace] || [];
+		eventRegistry[ev][namespace].push(handler);
+	}
+
+	if (isValidElement(this[0])) {
+		var eventRegistry = this[0].eventRegistry,
+			elem = this[0];
+
+
+		var _events = events.split(" ");
+		for (var endx = 0; endx < _events.length; endx++) {
+			var nsEvent = _events[endx].split("."),
+				ev = nsEvent[0],
+				namespace = nsEvent[1] || "global";
+			addEvent(ev, namespace);
+		}
+	}
+	return this;
+}
+
+function off(events, handler) {
+	var eventRegistry, elem;
+
+	function removeEvent(ev, namespace, handler) {
+		if (ev in eventRegistry === true) {
+			//unbind to dom events
+			if (elem.removeEventListener) { // all browsers except IE before version 9
+				elem.removeEventListener(ev, handler, false);
+			} else if (elem.detachEvent) { // IE before version 9
+				elem.detachEvent("on" + ev, handler);
+			}
+			if (namespace === "global") {
+				for (var nmsp in eventRegistry[ev]) {
+					eventRegistry[ev][nmsp].splice(eventRegistry[ev][nmsp].indexOf(handler), 1);
+				}
+			} else {
+				eventRegistry[ev][namespace].splice(eventRegistry[ev][namespace].indexOf(handler), 1);
+			}
+		}
+	}
+
+	function resolveNamespace(ev, namespace) {
+		var evts = [],
+			hndx, hndL;
+		if (ev.length > 0) {
+			if (handler === undefined) {
+				for (hndx = 0, hndL = eventRegistry[ev][namespace].length; hndx < hndL; hndx++) {
+					evts.push({
+						ev: ev,
+						namespace: namespace && namespace.length > 0 ? namespace : "global",
+						handler: eventRegistry[ev][namespace][hndx]
+					});
+				}
+			} else {
+				evts.push({
+					ev: ev,
+					namespace: namespace && namespace.length > 0 ? namespace : "global",
+					handler: handler
+				});
+			}
+		} else if (namespace.length > 0) {
+			for (var evNdx in eventRegistry) {
+				for (var nmsp in eventRegistry[evNdx]) {
+					if (nmsp === namespace) {
+						if (handler === undefined) {
+							for (hndx = 0, hndL = eventRegistry[evNdx][nmsp].length; hndx < hndL; hndx++) {
+								evts.push({
+									ev: evNdx,
+									namespace: nmsp,
+									handler: eventRegistry[evNdx][nmsp][hndx]
+								});
+							}
+						} else {
+							evts.push({
+								ev: evNdx,
+								namespace: nmsp,
+								handler: handler
+							});
+						}
+					}
+				}
+			}
+		}
+
+		return evts;
+	}
+
+	if (isValidElement(this[0]) && events) {
+		eventRegistry = this[0].eventRegistry;
+		elem = this[0];
+
+
+		var _events = events.split(" ");
+		for (var endx = 0; endx < _events.length; endx++) {
+			var nsEvent = _events[endx].split("."),
+				offEvents = resolveNamespace(nsEvent[0], nsEvent[1]);
+			for (var i = 0, offEventsL = offEvents.length; i < offEventsL; i++) {
+				removeEvent(offEvents[i].ev, offEvents[i].namespace, offEvents[i].handler);
+			}
+		}
+	}
+	return this;
+}
+
+function trigger(events /* , args... */) {
+	if (isValidElement(this[0])) {
+		var eventRegistry = this[0].eventRegistry,
+			elem = this[0];
+		var _events = typeof events === "string" ? events.split(" ") : [events.type];
+		for (var endx = 0; endx < _events.length; endx++) {
+			var nsEvent = _events[endx].split("."),
+				ev = nsEvent[0],
+				namespace = nsEvent[1] || "global";
+			if (document !== undefined && namespace === "global") {
+				//trigger domevent
+				var evnt, i, params = {
+					bubbles: true,
+					cancelable: true,
+					detail: arguments[1]
+				};
+				// The custom event that will be created
+				if (document.createEvent) {
+					try {
+						switch (ev) {
+							case "input":
+								params.inputType = "insertText";
+								evnt = new InputEvent(ev, params);
+								break;
+							default:
+								evnt = new CustomEvent(ev, params);
+						}
+					} catch (e) {
+						evnt = document.createEvent("CustomEvent");
+						evnt.initCustomEvent(ev, params.bubbles, params.cancelable, params.detail);
+					}
+					if (events.type) extend(evnt, events);
+					elem.dispatchEvent(evnt);
+				} else {
+					evnt = document.createEventObject();
+					evnt.eventType = ev;
+					evnt.detail = arguments[1];
+					if (events.type) extend(evnt, events);
+					elem.fireEvent("on" + evnt.eventType, evnt);
+				}
+			} else if (eventRegistry[ev] !== undefined) {
+				arguments[0] = arguments[0].type ? arguments[0] : DependencyLib.Event(arguments[0]);
+				arguments[0].detail = arguments.slice(1);
+				if (namespace === "global") {
+					for (var nmsp in eventRegistry[ev]) {
+						for (i = 0; i < eventRegistry[ev][nmsp].length; i++) {
+							eventRegistry[ev][nmsp][i].apply(elem, arguments);
+						}
+					}
+				} else {
+					for (i = 0; i < eventRegistry[ev][namespace].length; i++) {
+						eventRegistry[ev][namespace][i].apply(elem, arguments);
+					}
+				}
+			}
+		}
+	}
+	return this;
+}

package/node_modules/inputmask/lib/dependencyLibs/extend.js

@@ -0,0 +1,58 @@
+export default function extend() {
+	let options, name, src, copy, copyIsArray, clone,
+		target = arguments[0] || {},
+		i = 1,
+		length = arguments.length,
+		deep = false;
+
+	// Handle a deep copy situation
+	if (typeof target === "boolean") {
+		deep = target;
+
+		// Skip the boolean and the target
+		target = arguments[i] || {};
+		i++;
+	}
+
+	// Handle case when target is a string or something (possible in deep copy)
+	if (typeof target !== "object" && typeof target !== "function") {
+		target = {};
+	}
+
+	for (; i < length; i++) {
+		// Only deal with non-null/undefined values
+		if ((options = arguments[i]) != null) {
+			// Extend the base object
+			for (name in options) {
+				src = target[name];
+				copy = options[name];
+
+				// Prevent never-ending loop
+				if (target === copy) {
+					continue;
+				}
+
+				// Recurse if we're merging plain objects or arrays
+				if (deep && copy && (Object.prototype.toString.call(copy) === "[object Object]" || (copyIsArray = Array.isArray(copy)))) {
+					if (copyIsArray) {
+						copyIsArray = false;
+						clone = src && Array.isArray(src) ? src : [];
+
+					} else {
+						clone = src && Object.prototype.toString.call(src) === "[object Object]" ? src : {};
+					}
+
+					// Never move original objects, clone them
+					target[name] = extend(deep, clone, copy);
+
+					// Don't bring in undefined values
+				} else if (copy !== undefined) {
+					target[name] = copy;
+				}
+			}
+		}
+	}
+
+	// Return the modified object
+	return target;
+}

package/node_modules/inputmask/lib/dependencyLibs/inputmask.dependencyLib.jquery.js

@@ -5,8 +5,9 @@
  Licensed under the MIT license
  */
 
-var jquery = require("jquery");
-if(jquery === undefined) {
+import jQuery from "jquery";
+
+if (jQuery === undefined) {
 	throw "jQuery not loaded!";
 }
-module.exports = jquery;
+export default jQuery;