AS1024/itflow
1
0
Fork 0
mirror of https://github.com/itflow-org/itflow synced 2026-02-28 02:44:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrated from sbadmin to AdminLTE CSS framework

Browse Source
This commit is contained in:
johnny@pittpc.com
2019-11-19 18:29:02 -05:00
parent bf9b659283
commit e5036253ed
2393 changed files with 218489 additions and 148153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
vendor/Bootstrap-3-Typeahead/.gitignore vendored
View File

@@ -1,42 +0,0 @@
# Ignore docs files
_gh_pages
_site
.ruby-version
# Numerous always-ignore extensions
*.diff
*.err
*.log
*.orig
*.rej
*.swo
*.swp
*.vi
*.zip
*~
# OS or Editor folders
._*
.cache
.DS_Store
.idea
.project
.settings
.tmproj
*.esproj
*.sublime-project
*.sublime-workspace
nbproject
Thumbs.db
# Komodo
.komodotools
*.komodoproject
# grunt-html-validation
validation-report.json
validation-status.json
# Folders to ignore
bower_components
node_modules

34
vendor/Bootstrap-3-Typeahead/.jscsrc vendored
View File

@@ -1,34 +0,0 @@
{
"disallowEmptyBlocks": true,
"disallowKeywords": ["with"],
"disallowMixedSpacesAndTabs": true,
"disallowMultipleLineStrings": true,
"disallowMultipleVarDecl": true,
"disallowQuotedKeysInObjects": "allButReserved",
"disallowSpaceAfterPrefixUnaryOperators": ["++", "--", "+", "-", "~", "!"],
"disallowSpaceBeforeBinaryOperators": [","],
"disallowSpaceBeforePostfixUnaryOperators": ["++", "--"],
"disallowSpacesInNamedFunctionExpression": { "beforeOpeningRoundBrace": true },
"disallowSpacesInsideArrayBrackets": true,
"disallowSpacesInsideParentheses": true,
"disallowTrailingComma": true,
"disallowTrailingWhitespace": true,
"requireCamelCaseOrUpperCaseIdentifiers": true,
"requireCapitalizedConstructors": true,
"requireCommaBeforeLineBreak": true,
"requireDotNotation": true,
"requireLineFeedAtFileEnd": true,
"requireSpaceAfterBinaryOperators": ["+", "-", "/", "*", "=", "==", "===", "!=", "!==", ">", "<", ">=", "<="],
"requireSpaceAfterKeywords": ["if", "else", "for", "while", "do", "switch", "return", "try", "catch"],
"requireSpaceAfterLineComment": true,
"requireSpaceBeforeBinaryOperators": ["+", "-", "/", "*", "=", "==", "===", "!=", "!==", ">", "<", ">=", "<="],
"requireSpacesInAnonymousFunctionExpression": { "beforeOpeningCurlyBrace": true, "beforeOpeningRoundBrace": true },
"requireSpacesInConditionalExpression": true,
"requireSpacesInFunctionDeclaration": { "beforeOpeningCurlyBrace": true },
"requireSpacesInFunctionExpression": { "beforeOpeningCurlyBrace": true },
"requireSpacesInNamedFunctionExpression": { "beforeOpeningCurlyBrace": true },
"requireSpacesInsideObjectBrackets": "allButNested",
"validateIndentation": 2,
"validateLineBreaks": "LF",
"validateQuoteMarks": "'"
}

17
vendor/Bootstrap-3-Typeahead/.jshintrc vendored
View File

@@ -1,17 +0,0 @@
{
"asi" : true,
"browser" : true,
"node" : true,
"eqeqeq" : false,
"eqnull" : true,
"es3" : true,
"expr" : true,
"jquery" : true,
"latedef" : true,
"laxbreak" : true,
"nonbsp" : true,
"strict" : true,
"undef" : true,
"unused" : false,
"predef" : ["define"]
}

47
vendor/Bootstrap-3-Typeahead/Gruntfile.js vendored
View File

@@ -1,47 +0,0 @@
module.exports = function (grunt) {
'use strict';
// Force use of Unix newlines
grunt.util.linefeed = '\n';
// Project configuration.
grunt.initConfig({
// Metadata.
pkg: grunt.file.readJSON('package.json'),
jshint: {
options: {
jshintrc: '.jshintrc'
},
src: ['bootstrap3-typeahead.js']
},
jscs: {
src: "bootstrap3-typeahead.js",
options: {
config: ".jscsrc",
}
},
uglify: {
options: {
preserveComments: 'some'
},
core: {
files: {
'bootstrap3-typeahead.min.js': ['bootstrap3-typeahead.js']
}
}
}
});
// These plugins provide necessary tasks.
require('load-grunt-tasks')(grunt, { scope: 'devDependencies' });
//require('time-grunt')(grunt);
grunt.registerTask('test', ['jshint', 'jscs']);
// Default task.
grunt.registerTask('default', ['test','uglify']);
};

276
vendor/Bootstrap-3-Typeahead/README.md vendored
View File

@@ -1,276 +0,0 @@
Bootstrap 3 Typeahead
=====================
For simple autocomplete use cases there seems to be nothing wrong with the dropped typeahead plugin. Here you will find the typeahead autocomplete plugin for Twitter's Bootstrap 2 ready to use with Twitter's Bootstrap 3. The original code is written by [@mdo](http://twitter.com/mdo) and [@fat](http://twitter.com/fat).
Users who migrate their website or app from Twitter's Bootstrap 2 to Bootstrap 3 can also use this plugin to keep their current autocomplete functions. See for a complete list of migrations steps: [Migrate your templates from Twitter Bootstrap 2.x to Twitter Bootstrap 3](http://bassjobsen.weblogs.fm/migrate-your-templates-from-twitter-bootstrap-2-x-to-twitter-bootstrap-3/)
With Twitter Bootstrap 3 the typeahead plugin had been dropped. [@mdo](http://twitter.com/mdo) says: "in favor of folks using [Twitter's typeahead](https://github.com/twitter/typeahead.js). Twitter's typeahead has more features than the old bootstrap-typeahead.js and less bugs." Twitter's typeahead don't work direct with Bootstrap 3. The DOM structure of the dropdown menu used by `typeahead.js` differs from the DOM structure of the Bootstrap dropdown menu. You'll need to load some additional CSS in order to get the `typeahead.js` dropdown menu to fit the default Bootstrap theme. Try [extended Bootstrap LESS](https://github.com/bassjobsen/typeahead.js-bootstrap-css) or if your are looking for a more extended version try: [typeahead.js-bootstrap3.less](https://github.com/hyspace/typeahead.js-bootstrap3.less/blob/master/typeahead.less).
~~`Typeahead.js` doesn't seem ready for the new Twitter Bootstrap 3 at the moment. Code is not up to date and fixes are needed. See also:
[Typeahead problems with Bootstrap 3.0 RC1](http://stackoverflow.com/questions/18167246/typeahead-problems-with-bootstrap-3-0-rc1).~~
Bootstrap 4
===========
[Bootstrap 4](http://blog.getbootstrap.com/2015/08/19/bootstrap-4-alpha/) is coming soon. The Bootstrap 3 Typeahead will also work with Bootstrap 4.
The look and feel of Bootstrap 4 will differ from Bootstrap 3 and so does the drop down menu. In Bootstrap 4 the typeahead dropdown menu will look like that shown in the figure below:
![Bootstrap 4 Typeahead](typeaheadv4.png).
Download
========
- Download the latest [bootstrap3-typeahead.js](https://github.com/bassjobsen/Bootstrap-3-Typeahead/blob/master/bootstrap3-typeahead.js) or [bootstrap3-typeahead.min.js](https://github.com/bassjobsen/Bootstrap-3-Typeahead/blob/master/bootstrap3-typeahead.min.js).
- Include it in your source after jQuery and Bootstrap's JavaScript.
Full integration with Bootstrap 3 Typeahead
-------------------------------------------
Download the latest version of Boostrap from [Bootstrap](https://github.com/twbs/bootstrap/archive/master.zip). Copy `bootstrap3-typeahead.js` to the js/ folder. Edit `gruntfile.js` and add `bootstrap3-typeahead.js` to the plugins list.
Build your own version with typeahead with `grunt dist`.
CSS
===
There is no additional CSS required to use the plugin. Bootstrap's CSS contains all required styles in the `.dropdown-menu` class. The original CSS adds a `z-index` of 1051 to the dropdownmenu via the typeahead class. You could add this if you need it.
`.typeahead { z-index: 1051; }` (less or css).
Usage
=====
<input type="text" data-provide="typeahead">
You'll want to set `autocomplete="off"` to prevent default browser menus from appearing over the Bootstrap typeahead dropdown.
Via data attributes
-------------------
Add data attributes to register an element with typeahead functionality as shown in the example above.
Via JavaScript
--------------
Call the typeahead manually with:
$('.typeahead').typeahead()
Destroys previously initialized typeaheads. This entails reverting DOM modifications and removing event handlers:
$('.typeahead').typeahead('destroy')
Javascript Example
=============
Loading a collection
--------------------
$.get('example_collection.json', function(data){
$("#name").typeahead({ source:data });
},'json');
//example_collection.json
// ["item1","item2","item3"]
Using JSON objects instead of simple strings
--------------------------------------------
You can add all the properties you wish on your objects, as long as you provide a "name" attribute OR you provide your own displayText method. The other values allow you to match the selected item with something in your model.
var $input = $('.typeahead');
$input.typeahead({source:[{id: "someId1", name: "Display name 1"},
{id: "someId2", name: "Display name 2"}],
autoSelect: true});
$input.change(function() {
var current = $input.typeahead("getActive");
if (current) {
// Some item from your model is active!
if (current.name == $input.val()) {
// This means the exact match is found. Use toLowerCase() if you want case insensitive match.
} else {
// This means it is only a partial match, you can either add a new item
// or take the active if you don't want new items
}
} else {
// Nothing is active so it is a new value (or maybe empty value)
}
});
Options
=======
Options can be passed via data attributes or JavaScript. For data attributes, append the option name to `data-`, as in `data-source=""`.
<table class="table table-bordered table-striped">
<thead>
<tr>
<th style="width: 100px;">Name</th>
<th style="width: 50px;">Type</th>
<th style="width: 100px;">Default</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>source</td>
<td>array, function</td>
<td>[ ]</td>
<td>The data source to query against. May be an array of strings, an array of JSON object with a name property or a function. The function accepts two arguments, the <code>query</code> value in the input field and the <code>process</code> callback. The function may be used synchronously by returning the data source directly or asynchronously via the <code>process</code> callback's single argument.</td>
</tr>
<tr>
<td>items</td>
<td>number</td>
<td>8</td>
<td>The max number of items to display in the dropdown. Can also be set to 'all'</td>
</tr>
<tr>
<td>minLength</td>
<td>number</td>
<td>1</td>
<td>The minimum character length needed before triggering autocomplete suggestions. You can set it to 0 so suggestion are shown even when there is no text when lookup function is called.</td>
</tr>
<tr>
<td>showHintOnFocus</td>
<td>boolean or "all"</td>
<td>false</td>
<td>If hints should be shown as soon as the input gets focus. If set to true, all match will be shown. If set to "all", it will display all hints, not filtering them by the current text. This can be used when you want an input that behaves a bit like a combo box plus auto completion as you type to filter the choices.</td>
</tr>
<tr>
<td>scrollHeight</td>
<td>number, function</td>
<td>0</td>
<td>Number of pixels the scrollable parent container scrolled down (scrolled out the viewport).</td>
</tr>
<tr>
<td>matcher</td>
<td>function</td>
<td>case insensitive</td>
<td>The method used to determine if a query matches an item. Accepts a single argument, the <code>item</code> against which to test the query. Access the current query with <code>this.query</code>. Return a boolean <code>true</code> if query is a match.</td>
</tr>
<tr>
<td>sorter</td>
<td>function</td>
<td>exact match,<br> case sensitive,<br> case insensitive</td>
<td>Method used to sort autocomplete results. Accepts a single argument <code>items</code> and has the scope of the typeahead instance. Reference the current query with <code>this.query</code>.</td>
</tr>
<tr>
<td>updater</td>
<td>function</td>
<td>returns selected item</td>
<td>The method used to return selected item. Accepts a single argument, the <code>item</code> and has the scope of the typeahead instance.</td>
</tr>
<tr>
<td>highlighter</td>
<td>function</td>
<td>highlights all default matches</td>
<td>Method used to highlight autocomplete results. Accepts a single argument <code>item</code> and has the scope of the typeahead instance. Should return html.</td>
</tr>
<tr>
<td>displayText</td>
<td>function</td>
<td>item.name || item</td>
<td>Method used to get textual representation of an item of the sources. Accepts a single argument <code>item</code> and has the scope of the typeahead instance. Should return a String.</td>
</tr>
<tr>
<td>autoSelect</td>
<td>boolean</td>
<td>true</td>
<td>Allows you to dictate whether or not the first suggestion is selected automatically. Turning autoselect off also means that the input won't clear if nothing is selected and <kbd>enter</kbd> or <kbd>tab</kbd> is hit.</td>
</tr>
<tr>
<td>afterSelect</td>
<td>function</td>
<td>$.noop()</td>
<td>Call back function to execute after selected an item. It gets the current active item in parameter if any.</td>
</tr>
<tr>
<td>delay</td>
<td>integer</td>
<td>0</td>
<td>Adds a delay between lookups.</td>
</tr>
<tr>
<td>appendTo</td>
<td>jQuery element</td>
<td>null</td>
<td>By defaut, the menu is added right after the input element. Use this option to add the menu to another div. It should not be used if you want to use bootstrap dropup or dropdown-menu-right classes.</td>
</tr>
<tr>
<td>fitToElement</td>
<td>boolean</td>
<td>false</td>
<td>Set to true if you want the menu to be the same size than the input it is attached to.</td>
</tr>
<tr>
<td>addItem</td>
<td>JSON object</td>
<td>false</td>
<td>Adds an item to the end of the list, for example "New Entry". This could be used, for example, to pop a dialog when an item is not found in the list of data. Example: <a href="http://cl.ly/image/2u170I1q1G3A/addItem.png">http://cl.ly/image/2u170I1q1G3A/addItem.png</a></td>
</tr>
</tbody>
</table>
Methods
=======
.typeahead(options): Initializes an input with a typeahead.
.lookup: To trigger the lookup function externally
.getActive: To get the currently active item, you will get a String or a JSON object depending on how you initialized typeahead. Works only for the first match.
Bower
=====
To use with [Bower](http://bower.io/). Add to your bower.json file:
{
"name": "MyProject",
"dependencies": {
"bootstrap3-typeahead": "git://github.com/bassjobsen/Bootstrap-3-Typeahead.git#master"
}
}
AngularJS
=========
An AngularJS directive for the Bootstrap 3 Typeahead jQuery plugin can be found at https://github.com/davidkonrad/angular-bootstrap3-typeahead.
Bloodhound
==========
[Bloodhound](https://github.com/twitter/typeahead.js/blob/master/doc/bloodhound.md) is the [typeahead.js](https://github.com/twitter/typeahead.js) suggestion engine, since version 0.10.0. Bloodhound is robust, flexible, and offers advanced functionalities such as prefetching, intelligent caching, fast lookups, and backfilling with remote data. To use Bloodhound with Bootstrap-3-Typeahead:
// instantiate the bloodhound suggestion engine
var numbers = new Bloodhound({
datumTokenizer: Bloodhound.tokenizers.whitespace,
queryTokenizer: Bloodhound.tokenizers.whitespace,
local: ["(A)labama","Alaska","Arizona","Arkansas","Arkansas2","Barkansas"]
});
// initialize the bloodhound suggestion engine
numbers.initialize();
$('.typeahead').typeahead(
{
items: 4,
source:numbers.ttAdapter()
});
Bootstrap Tags Input
====================
[Bootstrap Tags Input](http://bootstrap-tagsinput.github.io/bootstrap-tagsinput/examples/) is a jQuery plugin providing a Twitter Bootstrap user interface for managing tags. Bootstrap Tags Input has a typeahead option which allows you to set the source:
$('input').tagsinput({
typeahead: {
source: ['Amsterdam', 'Washington', 'Sydney', 'Beijing', 'Cairo']
}
});
or
$('input').tagsinput({
typeahead: {
source: function(query) {
return $.get('http://someservice.com');
}
}
});
See also: https://github.com/bassjobsen/Bootstrap-3-Typeahead/issues/40

584
vendor/Bootstrap-3-Typeahead/bootstrap3-typeahead.js vendored
View File

@@ -1,584 +0,0 @@
/* =============================================================
* bootstrap3-typeahead.js v4.0.2
* https://github.com/bassjobsen/Bootstrap-3-Typeahead
* =============================================================
* Original written by @mdo and @fat
* =============================================================
* Copyright 2014 Bass Jobsen @bassjobsen
*
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an 'AS IS' BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ============================================================ */
(function (root, factory) {
'use strict';
// CommonJS module is defined
if (typeof module !== 'undefined' && module.exports) {
module.exports = factory(require('jquery'));
}
// AMD module is defined
else if (typeof define === 'function' && define.amd) {
define(['jquery'], function ($) {
return factory ($);
});
} else {
factory(root.jQuery);
}
}(this, function ($) {
'use strict';
// jshint laxcomma: true
/* TYPEAHEAD PUBLIC CLASS DEFINITION
* ================================= */
var Typeahead = function (element, options) {
this.$element = $(element);
this.options = $.extend({}, $.fn.typeahead.defaults, options);
this.matcher = this.options.matcher || this.matcher;
this.sorter = this.options.sorter || this.sorter;
this.select = this.options.select || this.select;
this.autoSelect = typeof this.options.autoSelect == 'boolean' ? this.options.autoSelect : true;
this.highlighter = this.options.highlighter || this.highlighter;
this.render = this.options.render || this.render;
this.updater = this.options.updater || this.updater;
this.displayText = this.options.displayText || this.displayText;
this.source = this.options.source;
this.delay = this.options.delay;
this.$menu = $(this.options.menu);
this.$appendTo = this.options.appendTo ? $(this.options.appendTo) : null;
this.fitToElement = typeof this.options.fitToElement == 'boolean' ? this.options.fitToElement : false;
this.shown = false;
this.listen();
this.showHintOnFocus = typeof this.options.showHintOnFocus == 'boolean' || this.options.showHintOnFocus === "all" ? this.options.showHintOnFocus : false;
this.afterSelect = this.options.afterSelect;
this.addItem = false;
this.value = this.$element.val() || this.$element.text();
};
Typeahead.prototype = {
constructor: Typeahead,
select: function () {
var val = this.$menu.find('.active').data('value');
this.$element.data('active', val);
if (this.autoSelect || val) {
var newVal = this.updater(val);
// Updater can be set to any random functions via "options" parameter in constructor above.
// Add null check for cases when updater returns void or undefined.
if (!newVal) {
newVal = '';
}
this.$element
.val(this.displayText(newVal) || newVal)
.text(this.displayText(newVal) || newVal)
.change();
this.afterSelect(newVal);
}
return this.hide();
},
updater: function (item) {
return item;
},
setSource: function (source) {
this.source = source;
},
show: function () {
var pos = $.extend({}, this.$element.position(), {
height: this.$element[0].offsetHeight
});
var scrollHeight = typeof this.options.scrollHeight == 'function' ?
this.options.scrollHeight.call() :
this.options.scrollHeight;
var element;
if (this.shown) {
element = this.$menu;
} else if (this.$appendTo) {
element = this.$menu.appendTo(this.$appendTo);
this.hasSameParent = this.$appendTo.is(this.$element.parent());
} else {
element = this.$menu.insertAfter(this.$element);
this.hasSameParent = true;
}
if (!this.hasSameParent) {
// We cannot rely on the element position, need to position relative to the window
element.css("position", "fixed");
var offset = this.$element.offset();
pos.top = offset.top;
pos.left = offset.left;
}
// The rules for bootstrap are: 'dropup' in the parent and 'dropdown-menu-right' in the element.
// Note that to get right alignment, you'll need to specify `menu` in the options to be:
// '<ul class="typeahead dropdown-menu" role="listbox"></ul>'
var dropup = $(element).parent().hasClass('dropup');
var newTop = dropup ? 'auto' : (pos.top + pos.height + scrollHeight);
var right = $(element).hasClass('dropdown-menu-right');
var newLeft = right ? 'auto' : pos.left;
// it seems like setting the css is a bad idea (just let Bootstrap do it), but I'll keep the old
// logic in place except for the dropup/right-align cases.
element.css({ top: newTop, left: newLeft }).show();
if (this.options.fitToElement === true) {
element.css("width", this.$element.outerWidth() + "px");
}
this.shown = true;
return this;
},
hide: function () {
this.$menu.hide();
this.shown = false;
return this;
},
lookup: function (query) {
var items;
if (typeof(query) != 'undefined' && query !== null) {
this.query = query;
} else {
this.query = this.$element.val() || this.$element.text() || '';
}
if (this.query.length < this.options.minLength && !this.options.showHintOnFocus) {
return this.shown ? this.hide() : this;
}
var worker = $.proxy(function () {
if ($.isFunction(this.source)) {
this.source(this.query, $.proxy(this.process, this));
} else if (this.source) {
this.process(this.source);
}
}, this);
clearTimeout(this.lookupWorker);
this.lookupWorker = setTimeout(worker, this.delay);
},
process: function (items) {
var that = this;
items = $.grep(items, function (item) {
return that.matcher(item);
});
items = this.sorter(items);
if (!items.length && !this.options.addItem) {
return this.shown ? this.hide() : this;
}
if (items.length > 0) {
this.$element.data('active', items[0]);
} else {
this.$element.data('active', null);
}
// Add item
if (this.options.addItem){
items.push(this.options.addItem);
}
if (this.options.items == 'all') {
return this.render(items).show();
} else {
return this.render(items.slice(0, this.options.items)).show();
}
},
matcher: function (item) {
var it = this.displayText(item);
return ~it.toLowerCase().indexOf(this.query.toLowerCase());
},
sorter: function (items) {
var beginswith = [];
var caseSensitive = [];
var caseInsensitive = [];
var item;
while ((item = items.shift())) {
var it = this.displayText(item);
if (!it.toLowerCase().indexOf(this.query.toLowerCase())) beginswith.push(item);
else if (~it.indexOf(this.query)) caseSensitive.push(item);
else caseInsensitive.push(item);
}
return beginswith.concat(caseSensitive, caseInsensitive);
},
highlighter: function (item) {
var html = $('<div></div>');
var query = this.query;
var i = item.toLowerCase().indexOf(query.toLowerCase());
var len = query.length;
var leftPart;
var middlePart;
var rightPart;
var strong;
if (len === 0) {
return html.text(item).html();
}
while (i > -1) {
leftPart = item.substr(0, i);
middlePart = item.substr(i, len);
rightPart = item.substr(i + len);
strong = $('<strong></strong>').text(middlePart);
html
.append(document.createTextNode(leftPart))
.append(strong);
item = rightPart;
i = item.toLowerCase().indexOf(query.toLowerCase());
}
return html.append(document.createTextNode(item)).html();
},
render: function (items) {
var that = this;
var self = this;
var activeFound = false;
var data = [];
var _category = that.options.separator;
$.each(items, function (key,value) {
// inject separator
if (key > 0 && value[_category] !== items[key - 1][_category]){
data.push({
__type: 'divider'
});
}
// inject category header
if (value[_category] && (key === 0 || value[_category] !== items[key - 1][_category])){
data.push({
__type: 'category',
name: value[_category]
});
}
data.push(value);
});
items = $(data).map(function (i, item) {
if ((item.__type || false) == 'category'){
return $(that.options.headerHtml).text(item.name)[0];
}
if ((item.__type || false) == 'divider'){
return $(that.options.headerDivider)[0];
}
var text = self.displayText(item);
i = $(that.options.item).data('value', item);
i.find('a').html(that.highlighter(text, item));
if (text == self.$element.val()) {
i.addClass('active');
self.$element.data('active', item);
activeFound = true;
}
return i[0];
});
if (this.autoSelect && !activeFound) {
items.filter(':not(.dropdown-header)').first().addClass('active');
this.$element.data('active', items.first().data('value'));
}
this.$menu.html(items);
return this;
},
displayText: function (item) {
return typeof item !== 'undefined' && typeof item.name != 'undefined' && item.name || item;
},
next: function (event) {
var active = this.$menu.find('.active').removeClass('active');
var next = active.next();
if (!next.length) {
next = $(this.$menu.find('li')[0]);
}
next.addClass('active');
},
prev: function (event) {
var active = this.$menu.find('.active').removeClass('active');
var prev = active.prev();
if (!prev.length) {
prev = this.$menu.find('li').last();
}
prev.addClass('active');
},
listen: function () {
this.$element
.on('focus', $.proxy(this.focus, this))
.on('blur', $.proxy(this.blur, this))
.on('keypress', $.proxy(this.keypress, this))
.on('input', $.proxy(this.input, this))
.on('keyup', $.proxy(this.keyup, this));
if (this.eventSupported('keydown')) {
this.$element.on('keydown', $.proxy(this.keydown, this));
}
this.$menu
.on('click', $.proxy(this.click, this))
.on('mouseenter', 'li', $.proxy(this.mouseenter, this))
.on('mouseleave', 'li', $.proxy(this.mouseleave, this))
.on('mousedown', $.proxy(this.mousedown,this));
},
destroy : function () {
this.$element.data('typeahead',null);
this.$element.data('active',null);
this.$element
.off('focus')
.off('blur')
.off('keypress')
.off('input')
.off('keyup');
if (this.eventSupported('keydown')) {
this.$element.off('keydown');
}
this.$menu.remove();
this.destroyed = true;
},
eventSupported: function (eventName) {
var isSupported = eventName in this.$element;
if (!isSupported) {
this.$element.setAttribute(eventName, 'return;');
isSupported = typeof this.$element[eventName] === 'function';
}
return isSupported;
},
move: function (e) {
if (!this.shown) return;
switch (e.keyCode) {
case 9: // tab
case 13: // enter
case 27: // escape
e.preventDefault();
break;
case 38: // up arrow
// with the shiftKey (this is actually the left parenthesis)
if (e.shiftKey) return;
e.preventDefault();
this.prev();
break;
case 40: // down arrow
// with the shiftKey (this is actually the right parenthesis)
if (e.shiftKey) return;
e.preventDefault();
this.next();
break;
}
},
keydown: function (e) {
this.suppressKeyPressRepeat = ~$.inArray(e.keyCode, [40,38,9,13,27]);
if (!this.shown && e.keyCode == 40) {
this.lookup();
} else {
this.move(e);
}
},
keypress: function (e) {
if (this.suppressKeyPressRepeat) return;
this.move(e);
},
input: function (e) {
// This is a fixed for IE10/11 that fires the input event when a placehoder is changed
// (https://connect.microsoft.com/IE/feedback/details/810538/ie-11-fires-input-event-on-focus)
var currentValue = this.$element.val() || this.$element.text();
if (this.value !== currentValue) {
this.value = currentValue;
this.lookup();
}
},
keyup: function (e) {
if (this.destroyed) {
return;
}
switch (e.keyCode) {
case 40: // down arrow
case 38: // up arrow
case 16: // shift
case 17: // ctrl
case 18: // alt
break;
case 9: // tab
case 13: // enter
if (!this.shown) return;
this.select();
break;
case 27: // escape
if (!this.shown) return;
this.hide();
break;
}
},
focus: function (e) {
if (!this.focused) {
this.focused = true;
if (this.options.showHintOnFocus && this.skipShowHintOnFocus !== true) {
if(this.options.showHintOnFocus === "all") {
this.lookup("");
} else {
this.lookup();
}
}
}
if (this.skipShowHintOnFocus) {
this.skipShowHintOnFocus = false;
}
},
blur: function (e) {
if (!this.mousedover && !this.mouseddown && this.shown) {
this.hide();
this.focused = false;
} else if (this.mouseddown) {
// This is for IE that blurs the input when user clicks on scroll.
// We set the focus back on the input and prevent the lookup to occur again
this.skipShowHintOnFocus = true;
this.$element.focus();
this.mouseddown = false;
}
},
click: function (e) {
e.preventDefault();
this.skipShowHintOnFocus = true;
this.select();
this.$element.focus();
this.hide();
},
mouseenter: function (e) {
this.mousedover = true;
this.$menu.find('.active').removeClass('active');
$(e.currentTarget).addClass('active');
},
mouseleave: function (e) {
this.mousedover = false;
if (!this.focused && this.shown) this.hide();
},
/**
* We track the mousedown for IE. When clicking on the menu scrollbar, IE makes the input blur thus hiding the menu.
*/
mousedown: function (e) {
this.mouseddown = true;
this.$menu.one("mouseup", function(e){
// IE won't fire this, but FF and Chrome will so we reset our flag for them here
this.mouseddown = false;
}.bind(this));
},
};
/* TYPEAHEAD PLUGIN DEFINITION
* =========================== */
var old = $.fn.typeahead;
$.fn.typeahead = function (option) {
var arg = arguments;
if (typeof option == 'string' && option == 'getActive') {
return this.data('active');
}
return this.each(function () {
var $this = $(this);
var data = $this.data('typeahead');
var options = typeof option == 'object' && option;
if (!data) $this.data('typeahead', (data = new Typeahead(this, options)));
if (typeof option == 'string' && data[option]) {
if (arg.length > 1) {
data[option].apply(data, Array.prototype.slice.call(arg, 1));
} else {
data[option]();
}
}
});
};
$.fn.typeahead.defaults = {
source: [],
items: 8,
menu: '<ul class="typeahead dropdown-menu" role="listbox"></ul>',
item: '<li><a class="dropdown-item" href="#" role="option"></a></li>',
minLength: 1,
scrollHeight: 0,
autoSelect: true,
afterSelect: $.noop,
addItem: false,
delay: 0,
separator: 'category',
headerHtml: '<li class="dropdown-header"></li>',
headerDivider: '<li class="divider" role="separator"></li>'
};
$.fn.typeahead.Constructor = Typeahead;
/* TYPEAHEAD NO CONFLICT
* =================== */
$.fn.typeahead.noConflict = function () {
$.fn.typeahead = old;
return this;
};
/* TYPEAHEAD DATA-API
* ================== */
$(document).on('focus.typeahead.data-api', '[data-provide="typeahead"]', function (e) {
var $this = $(this);
if ($this.data('typeahead')) return;
$this.typeahead($this.data());
});
}));

1
vendor/Bootstrap-3-Typeahead/bootstrap3-typeahead.min.js vendored
View File

File diff suppressed because one or more lines are too long

20
vendor/Bootstrap-3-Typeahead/bower.json vendored
View File

@@ -1,20 +0,0 @@
{
"name": "bootstrap3-typeahead",
"version": "4.0.2",
"authors": [
"bassjobsen"
],
"main": [
"bootstrap3-typeahead.js"
],
"ignore": [
"**/.*",
"node_modules",
"bower_components",
"test",
"tests"
],
"dependencies": {
"jquery": ">=1.7.0"
}
}

21
vendor/Bootstrap-3-Typeahead/composer.json vendored
View File

@@ -1,21 +0,0 @@
{
"name": "bassjobsen/bootstrap-3-typeahead",
"type": "component",
"license": "Apache-2.0",
"description": "Bootstrap 3 Typeahead",
"minimum-stability": "dev",
"authors": [
{
"name": "Bass Jobsen",
"email": "bass@w3masters.nl"
}
],
"extra": {
"component": {
"files": [
"bootstrap3-typeahead.js",
"bootstrap3-typeahead.min.js"
]
}
}
}

36
vendor/Bootstrap-3-Typeahead/package.json vendored
View File

@@ -1,36 +0,0 @@
{
"name": "bootstrap-3-typeahead",
"description": "Bootstrap 3 Typeahead: The typeahead autocomplete plugin for Twitter's Bootstrap 2 ready to use with Bootstrap 3.",
"version": "4.0.2",
"main": "bootstrap3-typeahead.js",
"keywords": [
"typeahead",
"autocomplete",
"plugin",
"jquery",
"bootstrap"
],
"homepage": "https://github.com/bassjobsen/Bootstrap-3-Typeahead/",
"author": "Bass Jobsen",
"scripts": {
"test": "grunt test"
},
"repository": {
"type": "git",
"url": "https://github.com/bassjobsen/Bootstrap-3-Typeahead.git"
},
"bugs": {
"url": "https://github.com/bassjobsen/Bootstrap-3-Typeahead/issues"
},
"license": "MIT",
"devDependencies": {
"grunt": "~0.4.5",
"grunt-contrib-jshint": "~0.10.0",
"grunt-contrib-uglify": "~0.6.0",
"grunt-jscs": "~0.8.1",
"load-grunt-tasks": "~0.6.0"
},
"engines": {
"node": "~0.10.1"
}
}

BIN
vendor/Bootstrap-3-Typeahead/typeaheadv4.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.0 KiB

48
vendor/Inputmask/.eslintrc vendored
View File

@@ -1,48 +0,0 @@
{
"env": {
"browser": true,
"commonjs": true,
"node": true
},
"extends": "eslint:recommended",
"parserOptions": {
"ecmaVersion": 5
},
"rules": {
"indent": [
"error",
"tab",
{
"SwitchCase": 1
}
],
"linebreak-style": [
"off"
],
"quotes": [
"error",
"double"
],
"semi": [
"error",
"always"
],
"no-unused-vars": [
"error",
{
"vars": "all",
"args": "none"
}
],
"no-cond-assign": [
"error",
"except-parens"
]
},
"globals": {
"Inputmask": true,
"jQuery": false,
"define": false,
"require": false
}
}

39
vendor/Inputmask/.gitattributes vendored
View File

@@ -1,39 +0,0 @@
# These settings are for any web project
# Handle line endings automatically for files detected as text
# and leave all files detected as binary untouched.
* text=auto
#
# The above will handle all files NOT found below
#
# These files are text and should be normalized (Convert crlf => lf)
*.php text
*.css text
*.js text
*.htm text
*.html text
*.xml text
*.txt text
*.ini text
*.inc text
.htaccess text
# These files are binary and should be left untouched
# (binary is a macro for -text -diff)
*.png binary
*.jpg binary
*.jpeg binary
*.gif binary
*.ico binary
*.mov binary
*.mp4 binary
*.mp3 binary
*.flv binary
*.fla binary
*.swf binary
*.gz binary
*.zip binary
*.7z binary
*.ttf binary

35
vendor/Inputmask/.github/ISSUE_TEMPLATE/bug_report.md vendored
View File

@@ -1,35 +0,0 @@
---
name: Bug report
about: Create a report to help us improve
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Live example**
Add a link to a codepen, jsfiddle or other example page which shows the problem
**Desktop (please complete the following information):**
- OS: [e.g. iOS]
- Browser [e.g. chrome, safari]
- Version [e.g. 22]
**Smartphone (please complete the following information):**
- Device: [e.g. iPhone6]
- OS: [e.g. iOS8.1]
- Browser [e.g. stock browser, safari]
- Version [e.g. 22]
**Additional context**
Add any other context about the problem here.

17
vendor/Inputmask/.github/ISSUE_TEMPLATE/feature_request.md vendored
View File

@@ -1,17 +0,0 @@
---
name: Feature request
about: Suggest an idea for this project
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.

14
vendor/Inputmask/.gitignore vendored
View File

@@ -1,14 +0,0 @@
build/
test.html
jquery-1.10.2.js
dist/jQuery.InputMask.*.nupkg
node_modules/
bower_components/
npm-debug.log
.idea/
*.iml
qunit/qunit.js
qunit/qunit.js.map
package-lock.json
**/*.map
dist/*.LICENSE

646
vendor/Inputmask/CHANGELOG.md vendored
View File

@@ -1,646 +0,0 @@
# Change Log
## [5.0.0 - UNRELEASED]
### Addition
- add indian numbering support in numeric alias (indianns alias)
### Updates
- fix mask curruption when alternating and using jitmasking
- Casing option will also allow case insensitive entry for static symbols
- refactor numeric alias (ongoing - 8)
- package & bundling
- enhance regex alternations. ex: [01][0-9]|2[0-3] => ([01][0-9]|2[0-3])
- extend command object
- rewritePosition
### Fixed
- im-insert not valid html #2122
- No message with HTML5 validation #841
- Manual input via virtual keyboard doesn't work #2116
- Can't insert more than 2 letters in Firefox #2114
- InputMask not getting fresh placeholder value #2111
- Chrome autofill does not work with Inputmask #1330
- Paste in inputmask #2088
- The first character is truncated when masking. #2089
- No leading zero for single-digit hours KO #2061
- Only 1st placeholder is displayed for fields with same alias numeric #2060
- Original placeholder disappear when mouseout in IE #2047
- Document bug with disabled inputs caused by Firefox 64 and older #2045
- Behaviour of v3 with hours not possible anymore #1918
- Unmasked value of datetime alias, if empty, returns the placeholder #2039
## [4.0.4 - 2018-12-03]
### Addition
- add url as supported input type
### Updates
- rework jit enabled quantifiers
### Fixed
- restore greedy functionality
- fix focus and mouseenter behavior in IE
## [4.0.3 - 2018-11-07]
### Addition
- numeric.extensions - add inputType option to specify the type of initial value
- README_numeric.md => Setting initial values
### Updates
- fix window.js for node
### Fixed
- digits: 3 - error on transform #2022
- "Can not read property 'join' of undefined" when using Inputmask.format #2019
- Inputmask numeric does no round up when digits is 0 #2018
- Strange Calendar popup issue in IE Only when used with Daterangepicker #1965
- incorrect work min max date - #2011, #2013
## [4.0.2 - 2018-09-14]
(4.0.1 => 4.0.2 rebuild dist with newer version of uglify #2000)
### Updates
- <strong>remove phone alias</strong> (~ use https://github.com/RobinHerbots/inputmask.phone or https://github.com/andr-04/inputmask-multi instead) #1981
- enhance gettests for jit enabled quantifiers
- pass initial validation position to postvalidation, to allow prefills in the datetime alias
- remove caret selection for insertMode => use inputmask.css for visualization
- update nuget package
- update dependencies
### Fixed
- When blur input, inputmask adds attr placeholder to input - #1992
- Fix endless loop for quantifiers (see tests_dynamic.js - latest unittests) #1983
- Element keeps the focus to itself in ie11 #1846
- Changes for min/max options do not get picked up. #1931
- Behaviour of v3 with hours not possible anymore #1918
- Multiple alternators #1553
- jquery.inputmask: clearIncomplete and placeholder don't appear to do anything when array of masks used #1892
- Problem with delete masked date on iOS #1899
- Autofill corrupts input on email mask #1908(gl)
## [4.0.0 - 2018-05-26]
### Addition
- add support for beforeInput event with inputType (Input Events Level 2 - https://w3c.github.io/input-events/)
- extend positionCaretOnClick with "ignore" to ignore the click in the input
- jit enabled dynamic masks
- add support for input type search
- new datetime alias
- extend positionCaretOnClick with "select" to select the whole input on focus
- add regex option (replaces the Regex alias)
- CSS Unit Mask #1843
### Updates
- make behavior of [] an {0,1} consistent
- change default value from greedy option to false
- fix unmatched alternations in gettests. ("[0-9]{2}|[0-9]{3}" like masks)
- code cleanup and refactoring
- enhance determineTestTemplate
- oncomplete calls
- merge setValidPosition and stripValidPositions => revalidateMask
- remove canClearPosition hook
- change notation of optionalmarker, quantifiermarker, groupmarker
- drop prevalidator and cardinality support in definitions
- drop Regex alias
- drop all date/time related aliases => replaced by new datetime alias
- improve alternation logic
- improve inputfallback (Android)
- better caret handling in colormask
- disable autocorrect on safari when disablePredictiveText is used
- rename androidHack option to disablePredictiveText. Make it available for other platforms.
### Fixed
- Both date and time in same masked textbox #1888
- time input mask min and max #1674
- Bug: Using backspace when caret is not at the end messes up static placeholders #1525
- Fast typing text #1872
- jitMasking + disablePredictiveText causes android browser tab to stuck when clicked on "backspase" #1862
- Android 6 issue - Samsung device keyboard #1818
- Method oncomplete doesn't work correctly with jitMasking #1845
- isComplete in numeric extensions doesn't take into account negationSymbol #1844
- Email alias - retype @ removes last . #1324
- When "clearIncomplete: true" and pressing Enter to Submit Form #1839
- Hang on combination of optional mask and repeat #698
- Can't remove inputmask on focus? #1820
- Not able to input 31.12. in DD.MM date input in v4.x #1803
- problem with two separate alternations #1722
- colorMask + Remask = Duplicate im-colormask element #1709
### Note
Be aware when upgrading from 3.3.11, that the regex alias is removed
and that the datetime alias has totally changed.
So expect you need todo some changes to your date-masks and regex masks.
Also some defaults has changed, so have a read through the changes for this release.
There are still many open issues but postponing the release to resolve all issues will take like another year,
while there are already many enhancements available.
## [3.3.9 - 2017-10-10]
### Updates
- enhance inputfallback (Android)
### Fixes
- On Android with date mask input mashing up #1708
- Currency mask works incorrectly on Android Chrome v58 #1617
- Can't input character at the end if it's also a placeholder on Android #1648
## [3.3.8 - 2017-08-24]
### Addition
- Addition \uFF11-\uFF19 character range to 9 definition #1606
- importDataAttributes option #1633
- add dot support in regex #1651
### Updates
- pass inputmask object in the callbacks
- colorMask enhancement: better positioning and more controllable via inputmask.css
- remove maxLength attribute on android #1490
- enhance inputfallback (Android)
### Fixes
- Mask appear when I press TAB & showMaskOnFocus: false, showMaskOnHover: false #1198
- DependencyLib.Event CustomEvent #1642
- Wrong initial cursor position with Numeric and Prefix #1578
- Currency mask works incorrectly on Android Chrome v58 #1617
- Can't input character at the end if it's also a placeholder on Android #1648
- colorMask - incorrect positioning #1421
- Object doesn't support property or method '_valueGet' in version 3.3.7 #1645
- Usage of numericInput in data-inputmask causes reversed value #1640
- Numeric suffix makes radixPoint disappear on preset value #1638
- Cannot delete after fill up all the mask Android Chrome browser Jsfiddle #1637
## [3.3.7 - 2017-06-09]
### Addition
- allow custom operation in casing option by callback #1565
### Updates
- put back Regex alias extension for legacy support #1611
- postvalidation cannot set pos of undefined
- fix undoValue initialization
### Fixed
- Major issue with regex #1611
- React onChange event doesn't work with Inputmask #1377
- Currency digits and delete #1351
- Decimal editing problems #1603
- UX problem with email mask #1600
- Force numeric to empty (on blur) with '0' as value #215
- ndxInitializer.shift is not a function
## [3.3.6 - 2017-05-11]
### Addition
- noValuePatching option #1276
### Updates
- drop Regex alias => use the inputmask regex option instead
- alternator syntax update - regex like alternations is now supported (aa|99|AA) ~ aa or 99 or AA
### Fixed
- NaN with negationSymbol and unmaskAsNumber #1581
- A dot (.) in Regex Causes Errors #647
- variable "undoValue" isn't initialized correctly #1519
- on submit change event is triggered #1392
- Change Event Problems for Masked Input #1583
- integer backspace bug when set maxLength attr. #1546
- Regex with placeholder, not working? #798
- Visualize regular expressions #1040
- Mobile phone code update needed for Malaysia #1571
- suffix bug (regression) #1558
- 29 february of non leap-year #1567
## [3.3.5 - 2017-04-10]
### Addition
- add example webpack setup (thx to Kevin Suen)
- build-in regex support without extension (WIP)
### Updates
- Change package name to Inputmask to better reflect that Inputmask doesn't require jQuery
- make removing the inputmask take the autoUnmask option into account
- enhance inputfallback event (android)
- restructure project
- performance updates
- initialization
### Fixed
- Changes are not reflected back to model when using with Vue2 (mobile) #1468
- Multiple alternators #1553
- Weird Issue with decimal masking when value is like 0.55 #1512
- IE 8 problems with currency and jquery.inputmask.bundle.js #1545
- Rounding error for numeric aliases #1300
- Currency InputMask Input Value issue with numericInput: true #1269
- onCleared event doesn't fire with 'numeric' alias in some case #1495
- Currency InputMask Input Value issue with numericInput: true #1269
- Rounding numeric values #1540
- Casing lower/upper as extend aliases? #1529
- This line of code returns an unexpected value when unmasking as number #1527
- Phone Mask Cursor Issue on Chrome on some Androids.. #1490
- min value issue fix #1177
- static is a reserved keyword #1479
- hasOwnProperty check missing in reverseTokens (numericInput) #1486
- Per-element radixPoint overwrites defaults #1454
- Form not cleaning correctly when AutoUnmask option is set to true #1442
- Form can`t submitted with input[name=disabled] #1473
## [3.3.4 - 2016-12-22]
### Addition
- extra extension points: analyseMask
- colorMask option ~ css styleable mask
### Updates
- remove tooltip option
- remove h,s,d,m,y definitions => use the date/time aliases
- phone-alias - fine-tune mask sorting
- make data-inputmask attribute naming configurable (dataAttribute on Inputmask)
- numeric alias move negation symbols to the edges
- handle android predictive text enabled
- rename js/inputmask.dependencyLib.jquery.js to js/inputmask.dependencyLib.js
- rename dist/inputmask.dependencyLib.jquery.js to dist/inputmask.dependencyLib.js
- commonjs dep to inputmask.dependencyLib instead to inputmask.dependencyLib.jquery => can be symlinked to another dependencyLib
- improve inputfallback (Android support)
### Fixed
- IE11 : SCRIPT438: Object doesn't support property or method 'isFinite' #1472
- () as literal followed by an optional, doubles the optional template #1453
- Decimal mask excluding zero with custom RadixPoint and GroupSeparator #1418
- Can't remove dot from the middle of a word #1439
- Invalid Leap Year dates can be entered #1368
- jquery.val returns empty value (when using an unsupported input type) #1415
- Losing the decimal part when the maximum number of digits is reached #1257
- Not allowing to change existing number to 0 #1381
- Numbers get swapped when cursor near suffix. #1278
- androidHack: Caret positioning needs some fine tuning #1412
- How can I get "-$123.45", not "$-123.45"? #1360
- Placeholder color #972
- Other color on placeholder (wrap placeholder in span, using contenteditable?) #873
- Error on 3.3.3: Uncaught TypeError: Cannot set property 'generatedInput' of undefined #1399
- ios 8, safari, on first visit unable to enter any characters #826
- Numerica mask not run in Galaxy S5 + Chrome + Android #1357
## [3.3.3 - 2016-09-09] - hotfix
### Updates
- revert moving jquery dependencyLib
- correct caret positioning - radixFocus & placeholder: ""
### Fixed
- Build failure in heroku after release of 3.3.2 #1384
- Error with inputMask any case (v3.3.2) #1383
## [3.3.2 - 2016-09-09]
### Addition
- mask-level casing => #1352
- 'casing': 'title' #1277
- add quantifier syntax for digits option in numeric alias. #1374
### Updates
- add bundle in nuget package
- change default of positionCaretOnTab to true
- include min files in nuspecs
- better filter for input targets in inputmask.binder.js
- improve alternation selection
- removed nojumps option
- update phone alias implementation
- add unit tests for phonecodes
- replaced radixFocus option by positionCaretOnClick. Allows choice for behavior of the caret on click. (none, lvp (default), radixFocus)
- performance updates
- getmasklength
- use selective caching in getTests
### Fixed
- Problems with greedy dynamic masks in current version 3.x #1375
- Croatian phone mask only supports city of Zagreb #1359
- Pasting to masked input not working on Android #1061
- Unable to get property 'forwardPosition' of undefined or null reference IE11 #1342
- Input event doesn't fire in IE #1287
- Dynamically changing mask based on number of entered characters #1336
- change addEventListener not fired in IE11 #1310 - inputmask.dependencyLib.js
- Hide mask's items that have multiple options #678
- Bug when typing after a fixed character #1299
- onUnMask is not being called #1291
- How Can I have caret position on decimal digit(after decimal point) for currency inputmask ? #1282
- How to implement mask for these numbers? #840 (alternator)
- 'setvalue' on mask with a suffix results in suffix being doubled, while `$.fn.val` works fine #1267
## [3.3.1] - 2016-04-20
### Updates
- better handle alternator logic by merging the locators
- patchValueProperty - enable native value property patch on IE8/IE9
- speedup insert and delete from characters
- adding extra options through option method => auto apply the mask + add noremask option
### Fixed
- Safari date mask - Context switch when jquery.valhook fallback is used #1255
- Email alias _@_ => _@_._ #1245
- Safari Error: RangeError: Maximum call stack size exceeded #1241
- Safari Maximum call stack size exceeded when inputmask bound twice #1226
## [3.3.0] - 2016-04-05
### Addition
- nullable option => switch to return the placeholder or null when nothing is entered
- VIN mask #1199
### Updates
- also escape []{}() in the prefix and suffix for decimals
- Can not change integer part when it is "0" #1192
- change funtionality of postValidation => result may be true|false
- improve getmetadata
- patchValueProperty - enable native value property patch on IE10/IE11
### Fixed
- PostValidation function fails when using placeholder and digitsOptional is false #1240
- min value issue #1177
- min value for decimal isn't working #1178
- InputMask remove a 0 in left side. (numericInput: true) #1238
- validate regular expression for indian vehicle registration number #1223
- Distinguish empty value and '$ 0.00' value for currency alias #1053
- 'alias': 'numeric', zero value #1221
- Clicking on a highlighted masked field does not set the caret to the first valid position (Chrome) #1218
- Caret Positioned After Last Decimal Digit Disallows Sign Input When digits Option Set #1139
- numeric alias produces "0.00" instead of null when cleared out. #902
- IE8 error: Object doesn't support this property or method #1217
- update negation handling for numeric alias
- NumericInput option can't handle 100.00 #1162
- "0.00" not displayed if "clearMaskOnLostFocus: true" #1171
- Lost zero while replacing a digit in group #1202
- RadixFocus problem #686
- Can not change integer part when it is "0" #1192
- "[object Object]" value after `$element.inputmask('setvalue', '')` call #1208
- Paste does not work properly when using numericInput #1195
- error occurs in safari 9.0.3 (11601.4.4) #1191
- Can not clear value when select all and press BACKSPACE in some circumstance #1179
- Email mask incorrectly including underscore #868 => allowed as not typed => result invalid
- AutoUnmask not working on IE11 #1187
- Email mask not accepting valid emails #971
- Deleting character from input with 'email' alias shifts all data #1052
- Fix some events like paste & cut for Vanilla dependencyLib #1072
## [3.2.7] - 2016-01-28
### Updates
- favor inputfallback for android
- enable IEMobile
### Fixed
- Firefox, Android - cursor jumps to the left in numeric mask #1138
- Issue in Android (Samsung GALAXY S5) #825
- time mask, backspace behavior on android chrome #817
- Android Chrome Browser #867
- Mask issue in Android with Swype Keyboard #692
- Pasting to masked input not working on Android #1061
- Decimal point/comma not working on Android 4.4 #1041
- Doesn't work on Android #1073
- numeric input in mobile #897
- Support for Android default browser #368
- Repeating a character and a number On Mobile #898
- Inputs are ignored on FF 39 on Android 5.0.2 #982
- Phone input mask duplicates each character on Samsung Android tablet #834
- Support for Android default browser #368
- fixed "valids is not defined" error #1166
## [3.2.6] - 2016-01-25
### Addition
- add jitMasking option
- supportsInputType option
- staticDefinitionSymbol (see readme)
- include textarea as a valid masking element
### Updates
- enhance inputfallback ~ merge mobileinputevent
- caching with cache-dependency check in the getTests fn
- implement missing parts in the jqlite DependencyLib
- Remove namespaces for events (simplifies implementing other dependencyLibs, besides jquery)
- update alternation logic
### Fixed
- Windows Phone User unable to set Date #993
- '405 not allowed' error on loading phone-codes.js on certain Ajax configuration. #1156
- Issue with reset of inputmask field #1157
- IE11 clear not working in emulated IE9 mode #1144
- Show placeholder as user types #1141
- Initial value like VAA gets truncated to V-__ with mask like "I{1,3}-ZZ" #1134
- Input mask can't be applied on other HTML5 input types #828
- IE9 SCRIPT445: Object does not support this action #1135
- Multiple Mask Click Focus Error #1133
- Double enter for submit #1131
- Multiple masks #760
- Cursor shifted to the RIGHT align any way. #1088
- No-strict mask #1084
- Inputmask not work with textarea #1128
## [3.2.5] - 2015-11-27
### Updates
- improve cursor positioning and placeholder handling
- remove $("selector").inputmask("mask", { mask: "99-999 ..." }) format from plugin
### Fixed
- Currency validator gives false negative if number of digits in integer part is not multiplier of groupSize #1122
- data-inputmask => mask with optionals not parsed correctly #1119
- Email mask doesn't allow to go to the domain part by mouse #885
- alias options from 'data-inputmask' is not used anymore #1113
- Numeric extensions don't supported with vanilla DependencyLib #1116
## [3.2.4] - 2015-11-20
### Updates
- allow passing an element id to the mask function
- allow passing a selector to the mask function
- fix for bower package
### Fixed
- get the pressed key onKeyValidation #1114
- write a global function for onKeyValidation #1111 => update readme
- NumericInput Causes err #856
- Certain phones not inputable #758
- I have a problems with mask input, I can't input Ukraine phone +380(XX)XXX-XX-XX #1050
- you can't write ukraine number to phone field +380999999999 #1019
- autoUnmask not work in newest release #1109
- Definition {_} throws an exception #1106 => update readme
- Uncaught TypeError for "percentage" alias #1108
- Wrong behavior for symbol delete in ip alias #1092
- fix element validation for the vanilla dependencyLib #1104
## [3.2.3] - 2015-11-09
### Addition
- Inputmask.remove
- inputmask.binding => automated inputmask binding for html attributes
- Add tooltip option
### Updates
- fix bug in maskscache - context mixing
- allow passing multiple inputs to mask function
- Improve handling of compositionevents
- improve extendAliases, extendDefinitions, extendDefaults
### Fixed
- Cannot erase input value throw mask symbols (Android 4.4, Android 4.2) #1090
- CTRL-x / Cut issue #948
- Double "Change" action when pressing Enter in Firefox #1070
- upper/lower case handling in data-inputmask-* #1079
- IE8 Null values after submit #1076
- Each character repeats on Mobile #912
- extra tooltip property #1071
- Numeric aliases insert '0' in input after clearing if there was fraction part #1067
- Clear optional tail in getvalue. See #1055 #1065
## [3.2.2] - 2015-10-07
### Fixed
- Missing comma in bower.json and component.json #1064
## [3.2.1] - 2015-10-07
### Addition
- inputmask.dependencyLib.jquery
- inputmask.dependencyLib.jqlite
### Updates
- namespace dependencyLib => inputmask.dependencyLib
- fix jquery.inputmask.bundle.js
- fix dependency paths for browserify
- update files to be included for package.json, bower.json, component.json
### Fixed
- oncomplete not called when set with option function #1033
- oncompleate set value incorrect action #1039
- JQuery dependency #517
- IsValid on Optional Mask returning false #1055
- Focus loop on IE9 with numeric.extensions #989
- Currency with autogroup and no digits not working #1062
- field input width characters cropped while writing #1060 (regression fix)
- DependencyLib error in Internet Explorer #1047
- Dynamically switching mask in same input box not functioning as expected #1016
- 3.2.0 Error extendDefinitions and extendAliases not functions #1024
- Browserify error: `Error: Cannot find module 'inputmask' from '/Users/.../node_modules/jquery.inputmask/dist/inputmask` #1030
- Invalid JSON phone-uk.js #1025
## [3.2.0] - 2015-09-04
### Addition
- add option command to set and retrieve options on an inputmask
- dependencyLib wrapper around needed jQuery functionality
- mac address alias #986
- tabThrough option - Tab and autoselect mask parts #433
- eslint testing in grunt validate task
- $.fn.inputmask("setvalue", value)
- jquery.clone support (also see $.fn.inputmask("setvalue", value))
- hexadecimal definition (# in inputmask.extensions.js)
- positionCaretOnTab option
- Inputmask.unmask
- numeric alias - increment/decrement by ctrl-up/ctrl-down
- numeric alias - round values
- percentage alias
- Inputmask class
- setting defaults / definitions / aliases
- Inputmask.extendDefaults
- Inputmask.extendDefinitions
- Inputmask.extendAliases
### Updates
- enhance caret positioning behavior & radicFocus
- change alfanumeric uppercase definition from # to &
- numericInput option also possible on dynamic-masks
- remove $.inputmask in favor of Inputmask class
- remove "jquery." in the naming of the extensions to better reflect their denpendency
- separate jquery plugin code from the inputmask core (first step to remove jquery dependency from the inputmask core)
- Update placeholder handling
### Fixed
- Mask cleared on ajax submit or jquery unobtrusive validation error #1020
- Update readme for numerics #994
- extra zeros in currency alias #1008
- masks parsing generate a Maximum call stack size exceeded #1007
- Issue using datamask-input attributes and event handlers #992
- Set specific inputmask option on already initialized control #949
- Money question #644
- Decimal numbers with fixed decimal part #990
- Focus loop on IE9 with numeric.extensions #989
- Numeric inputs with default value are setted to blank when submit the form #983
- Default Enter key function getting lost on an input mask text field #938
- Add JSHint and JSCS #879 => used eslint instead
- On google chrome, cannot use jquery to clone the inputmask control with data and events #713
- Cannot overwrite characters when highlighting the characters to the right of the decimal #974
- Decimal mask accepts "123,456." (RadixPoint with no number after it) #973
- Make numericInput work with complex masks #963
- Auto position cursor at end of data on focus #965
- Decimal separator conversion #919
- Entering a period on a blank 'numeric' alias input not allowed #888
- Typing 1000 becomes 1.00 using groupSeparator="." #959
- phone-codes.js is missing when installing with bower #937
- Repeat function doesn't work for dynamic masks #960
- Provide convenient method to unmask value #929
- Min value doesn't work with allowMinus #951
- Escape value is inconsistent after mask #935
- Escape optional marker, quantifiable marker, alternator marker and backslash not working #930
- Is numeric carret position broken? #928
- Decimal looses digits #924
- Firefox: cursor jumps to the right when clicking anywhere on the value #921
- Numeric inputMask doesn't rounds value #754
- <strike>Chinese / Japanese characters are unable to mask #198</strike>
- <strike>Infinite Loop on IE (v11) when using Japanese IME Keyboard #749</strike>
- Delete key not working properly #799
- Selecting and overwriting text will delete the character to the immediate right #914
- Can't delete digits after decimal point on negative numbers #892
- decimal : extra number after delete and typing new numbers #904
- Dynamic masks with {*} and zero repeats #875
- Mask does not alternate back after deleting digit #905
- never trigger 'input' event when paste after invoke inputmask #776
- Script looping start when add '.' between decimal values #870 ('.' part)
## [3.1.63] - 2015-05-04
### Addition
- Support for CommonJS (Browserify)
### Updates
- Allow masking the text content of other html-elements (other then div)
- Make alternators correctly handle alternations with different lengths
- better determine the last required position with multiple masks
### Fixed
- Script looping start when add '.' between decimal values #870 (script loop)
- Static masks fails when we set value="2015" for an input field where data-inputmask was "2999" #903
- contenteditable decimal #882
- Tab out does not work when element is readonly #884
- Change mask default for allowPlus and allowMinus #896
- Browser hangs after trying to type some additional digits at the start of a date field #876
- inputmask decimal with integerDigits or digits with maxlength can cause Browser freezed #889
- masking a password field #821 (reenable type=password)
- email inputmask "isComplete" always returns true #855
- When two masks specified backspace clears the whole input instead of last char #780
- Phone extention backspace problem #454
## [3.1.62] - 2015-03-26
### Addition
- Numeric alias: add unmaskAsNumber option
- import russian phone codes from inputmask-multi
- enable masking the text content in a div
- enable contenteditable elements for inputmask
- Update Command object to handle inserts and allow for multiple removes
- Add a change log
- Add Component package manager support - component.json
### Fixed
- updating a value on onincomplete event doesn't work #955
- $.inputmask.isValid("1A", { mask : "1A" }) returns false #858
- IE8 doesn't support window.getSelection js error #853
- Email with dot - paste not working #847
- Standard phone numbers in Brazil #836 (Part 1)
- Sequentional optional parts do not fully match #699
- How i fix that number problem? #835
- Form reset doesn't get same value as initial mask #842
- Numeric extension doesn't seem to support min/max values #830
- Numeric max filter #837
- Mask cache - 2 definitions for same mask #831
- Adding parentheses as a negative format for Decimal and Integer aliases (100) #451
- Should not allow "-" or "+" as numbers #815
- isComplete erroneously returning false when backspacing with an optional mask #824
## [3.1.61] - 2015-02-05
Initial start of a changelog
See commits for previous history.

99
vendor/Inputmask/Gruntfile.js vendored
View File

@@ -1,99 +0,0 @@
var webpackBuildConfig = require("./webpack.buildconfig");
var webpackJqueryConfig = require("./webpack.jqueryconfig");
module.exports = function (grunt) {
// Project configuration.
grunt.initConfig({
pkg: grunt.file.readJSON("package.json"),
clean: ["dist"],
bump: {
options: {
files: ["package.json", "bower.json", "composer.json"],
updateConfigs: ["pkg"],
commit: false,
createTag: false,
push: false,
prereleaseName: "beta"
}
},
release: {
options: {
bump: false,
commit: false,
add: false
}
},
nugetpack: {
dist: {
src: function () {
return "nuspecs/Inputmask.nuspec";
}(),
dest: "build/",
options: {
version: "<%= pkg.version %>"
}
},
dist2: {
src: function () {
return "nuspecs/jquery.inputmask.nuspec";
}(),
dest: "build/",
options: {
version: "<%= pkg.version %>"
}
}
},
nugetpush: {
dist: {
src: "build/InputMask.<%= pkg.version %>.nupkg",
options: {
source: "https://www.nuget.org"
}
},
dist2: {
src: "build/jquery.inputMask.<%= pkg.version %>.nupkg",
options: {
source: "https://www.nuget.org"
}
}
},
eslint: {
target: "lib/*.js"
},
availabletasks: {
tasks: {
options: {
filter: "exclude",
tasks: ["availabletasks", "default", "updateDistConfig"],
showTasks: ["user"]
}
}
},
webpack: {
main: webpackBuildConfig,
jquery: webpackJqueryConfig
},
copy: {
extensions: {
files: [
{src: "lib/bindings/inputmask.binding.js", dest: "dist/bindings/inputmask.binding.js"}
]
}
}
});
// Load the plugin that provides the tasks.
require("load-grunt-tasks")(grunt);
grunt.registerTask("publish", ["release", "nugetpack", "nugetpush"]);
grunt.registerTask("publishnext", function () {
grunt.config("release.options.npmtag", "next");
grunt.task.run("release");
});
grunt.registerTask("validate", ["webpack", "copy", "eslint"]);
grunt.registerTask("build", ["bump:prerelease", "clean", "webpack", "copy"]);
grunt.registerTask("build:patch", ["bump:patch", "clean", "webpack", "copy"]);
grunt.registerTask("build:minor", ["bump:minor", "clean", "webpack", "copy"]);
grunt.registerTask("build:major", ["bump:major", "clean", "webpack", "copy"]);
grunt.registerTask("default", ["availabletasks"]);
};

7
vendor/Inputmask/LICENSE.txt vendored
View File

@@ -1,7 +0,0 @@
Copyright (c) 2010 - 2018 Robin Herbots
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

1244
vendor/Inputmask/README.md vendored
View File

File diff suppressed because it is too large Load Diff

62
vendor/Inputmask/README_android.md vendored
View File

@@ -1,62 +0,0 @@
#Android support
Have a read thought the different android issues. (Android Information #465)
Bottomline, the problem is the predictive text functionality. There is no way to prevent or control the input, which gives undesired results
and side effects in the inputmask. I tried several ways multiple times. Compositionevents, inputevent only masking, all with partial success.
The behavior also changes with the keyboard used. (google keyboard, samsung keyboard, ...)
In general, masks which only accepts numeric input tend to work even with predictive text enabled. Inputmasks with alphanumeric input will all fail.
The solution would be a way to control (or hint) the predictive text or to disable it.
When browsers would implement the inputmode attribute, disabling will be possible.
[Inputmode html spec](https://html.spec.whatwg.org/multipage/forms.html#input-modalities:-the-inputmode-attribute)
[Inputmode chromestatus](https://www.chromestatus.com/feature/6225984592281600)
##Update 18/01/2017
It seems that the GBoard keyboard fires the keydown event only with 229 as keycode. This behavior is not considered a bug as other means should be used to handle input.
See https://github.com/w3c/input-events
##Update 10/10/2017
Masking on mobile devices is currently implemented solely based on the input event. The beforeinput event isn't common in the browsers yet and so cannot be used.
I renamed the androidHack option to disablePredictiveText, so the option is now also available for other platforms.
This can be enabled by passing true for the option.
<strike>
##The workaround, the patchwork, the bad and ugly ;-)
This is not enabled by default, because I find that the developer should be aware of what it does and what you need to take into account when using this hack.
What it does.
- changes the input type to password => disabled predictive text
- enables the colorMask option which creates a div, which surrounds the input.
So we type in the hidden password input and render the mask in the a created div.
To use the colorMask, you need to include the inputmask.css you might need to add some css-tweaks to make it all visually correct in your page.
To enable the workaround add the androidHack option to your individual masks or globally by setting defaults.
You should set the option to "rtfm".
```
Inputmask("myfancymask", {androidHack: "rtfm"}).mask(selector);
Inputmask.extendDefaults({ androidHack: "rtfm" });
```
</strike>
##Reporting android related issues
Before you submit an issue related to Android. Test the issue with and without predictive text enabled.
If the issue also occurs with predictive text disabled you may create an issue for it on Github.
Otherwise, retry the issue on a desktop browser and add the inputEventOnly: true and colorMask: true option.
If the problem is still there you may submit an issue.
Always include a jsfiddle or alike to ease reproducing the problem.
When the issue only occurs due to predictive text I cannot solve it, until browsers start implementing the inputmode attribute on inputs.

93
vendor/Inputmask/README_date.md vendored
View File

@@ -1,93 +0,0 @@
# datetime extensions
Date and Time masks.
# Aliases
- datetime
# Options
## inputFormat
Format used to input the date
ex:
- dd/mm/yyyy
- mm/dd/yyyy
- dd.mm.yyyy HH:MM:ss
###Supported symbols
- d
Day of the month as digits; no leading zero for single-digit days.
- dd
Day of the month as digits; leading zero for single-digit days.
- ddd
Day of the week as a three-letter abbreviation.
- dddd
Day of the week as its full name.
- m
Month as digits; no leading zero for single-digit months.
- mm
Month as digits; leading zero for single-digit months.
- mmm
Month as a three-letter abbreviation.
- mmmm
Month as its full name.
-yy
Year as last two digits; leading zero for years less than 10.
- yyyy
Year as 4 digits.
- h
Hours; no leading zero for single-digit hours (12-hour clock).
- hh
Hours; leading zero for single-digit hours (12-hour clock).
- hhh
Hours; no limit
-H
Hours; no leading zero for single-digit hours (24-hour clock).
- HH
Hours; leading zero for single-digit hours (24-hour clock).
- HHH
Hours; no limit
- M
Minutes; no leading zero for single-digit minutes. Uppercase M unlike CF timeFormat's m to avoid conflict with months.
- MM
Minutes; leading zero for single-digit minutes. Uppercase MM unlike CF timeFormat's mm to avoid conflict with months.
- s
Seconds; no leading zero for single-digit seconds.
- ss
Seconds; leading zero for single-digit seconds.
- l
Milliseconds. 3 digits.
- L
Milliseconds. 2 digits.
- t
Lowercase, single-character time marker string: a or p.
- tt
Two-character time marker string: am or pm.
- T
Single-character time marker string: A or P.
- TT
Two-character time marker string: AM or PM.
- Z
US timezone abbreviation, e.g. EST or MDT. With non-US timezones or in the Opera browser, the GMT/UTC offset is returned, e.g. GMT-0500
- o
GMT/UTC timezone offset, e.g. -0500 or +0230.
- S
The date's ordinal suffix (st, nd, rd, or th). Works well with d.
### Optional parts
To mark a part of the inputFormat as optional, use the [] as you would for other masks.
Ex.
inputFormat: "dd/mm/yyyy [HH]"
## displayFormat
Visual format when the input looses focus
## outputFormat
Unmasking format
## min
Minimum value. This needs to be in the same format as the inputfornat
## max
Maximum value. This needs to be in the same format as the inputfornat,

99
vendor/Inputmask/README_numeric.md vendored
View File

@@ -1,99 +0,0 @@
# numeric extensions
## Aliases
- numeric
- currency
- decimal
- integer
- percentage
## Options
### digits
Number of fractionalDigits
Default: "*"
The value can be a number, *, or a quantifier syntax like 2,4
When the quantifier syntax is used, the digitsOptional option is ignored
### digitsOptional
Specify wheter the digits are optional.
Default: true
### enforceDigitsOnBlur
Enforces the decimal part when leaving the input field.
### allowMinus
Allow to enter -.
Default: true
### negationSymbol
Define your negationSymbol.
Default: {
front: "-", //"("
back: "" //")"
}
### prefix
Define a prefix.
Default: ""
### suffix
Define a suffix.
Default: ""
### min
Minimum value
Default: undefined
### max
Maximum value
Default: undefined
### step
Define the step the ctrl-up & ctrl-down must take.
Default: 1
### unmaskAsNumber
Make unmasking returning a number instead of a string.
Default: false
Be warned that using the unmaskAsNumber option together with jQuery.serialize will fail as serialize expects a string. (See issue [#1288])
[#1288]: https://github.com/RobinHerbots/jquery.inputmask/issues/1288
### inputType
Indicates whether the value passed for initialization is text or a number
Default: "text"
### Setting initial values
When initializing the mask with a value, you need to take some rules into account.
Depending of the option inputType the value will be interpreted as text or as a number.
When inputType is text, the symbol of the radixPoint must be correct. When using number the . (dot) is used as radixpoint.
Setting a number will always work when using vanilla javascript setters.
Example with komma (,) as radixpoint
```
/html
<input name="npt" value="123456,789"/>
//js
Inputmask("decimal", {
radixPoint: ',',
inputtype: "text"
}).mask("input");
$("input").val("123456,789");
$("input").val(123456.789); //this doesn't work because jQuery converts the number to a string
before passing it along to the Inputmask.
document.getElementsByName("npt")[0].value = "123456,789";
document.getElementsByName("npt")[0].value = 123456.789; //type number
```

43
vendor/Inputmask/README_other.md vendored
View File

@@ -1,43 +0,0 @@
# other extensions
## Definitions
- A : alphabetical uppercasing
- & : alfanumeric uppercasing
- \# : hexadecimal
## Aliases
### URL
An URL mask for entering valid FTP, HTTP or HTTPS addresses.
```javascript
Inputmask("url").mask(selector);
```
### IP address
An IP address alias for entering valid IP addresses.
```javascript
Inputmask("ip").mask(selector);
```
### Email
An email mask for entering valid email addresses.
```javascript
Inputmask("email").mask(selector);
```
### MAC
An MAC mask for entering valid MAC addresses.
```javascript
Inputmask("mac").mask(selector);
```
### VIN (Vehicle identification number)
An VIN mask for entering valid VIN codes.
```javascript
Inputmask("vin").mask(selector);
```
You can find/modify/extend these aliases in the inputmask.extensions.js

27
vendor/Inputmask/bower.json vendored
View File

@@ -1,27 +0,0 @@
{
"name": "inputmask",
"version": "5.0.0-beta.190",
"main": [
"./index.js",
"./css/inputmask.css"
],
"keywords": ["jquery", "plugins", "input", "form", "inputmask", "mask"],
"description": "Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.",
"license": "http://opensource.org/licenses/mit-license.php",
"ignore": [
"**/*",
"!index.js",
"!bundle.js",
"!bundle.jquery.js",
"!css/**/*",
"!dist/**/*",
"!lib/**/*"
],
"dependencies": {
"jquery": ">=1.7"
},
"authors": [{
"name": "Robin Herbots"
}],
"homepage": "http://robinherbots.github.io/Inputmask"
}

8
vendor/Inputmask/bundle.jquery.js vendored
View File

@@ -1,8 +0,0 @@
var im = require("./bundle");
var jQuery = require("jquery");
if (im.dependencyLib === jQuery) {
require("./lib/jquery.inputmask");
}
module.exports = im;

6
vendor/Inputmask/bundle.js vendored
View File

@@ -1,6 +0,0 @@
// import "./css/inputmask.css";
require("./lib/extensions/inputmask.extensions");
require("./lib/extensions/inputmask.date.extensions");
require("./lib/extensions/inputmask.numeric.extensions");
module.exports = require("./lib/inputmask.js");

12
vendor/Inputmask/composer.json vendored
View File

@@ -1,12 +0,0 @@
{
"name": "robinherbots/inputmask",
"description": "Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.",
"version": "5.0.0-beta.190",
"type": "library",
"keywords": ["jquery", "plugins", "input", "form", "inputmask", "mask"],
"homepage": "http://robinherbots.github.io/Inputmask",
"license": "MIT",
"authors": [{
"name": "Robin Herbots"
}]
}

69
vendor/Inputmask/css/inputmask.css vendored
View File

@@ -1,69 +0,0 @@
mark.im-caret {
animation: 1s blink step-end infinite !important;
}
mark.im-caret-select {
background-color: rgba(0, 0, 0, 0.25);
}
@keyframes blink {
from, to {
border-right-color: black;
}
50% {
border-right-color: transparent;
}
}
span.im-static {
color: grey;
}
div.im-colormask {
display: inline-block;
border-style: inset;
border-width: 2px;
appearance: textfield;
cursor: text;
}
div.im-colormask > input, div.im-colormask > input:-webkit-autofill {
position: absolute !important;
display: inline-block;
background-color: transparent;
color: transparent;
-webkit-text-fill-color: transparent;
transition: background-color 5000s ease-in-out 0s;
caret-color: transparent;
text-shadow: none;
appearance: caret;
border-style: none;
left: 0; /*calculated*/
}
div.im-colormask > input:focus {
outline: none;
}
div.im-colormask > input::selection {
background: none;
}
div.im-colormask > input::-moz-selection {
background: none;
}
div.im-colormask > input:-webkit-autofill ~ div {
background-color: rgb(250, 255, 189);
}
div.im-colormask > div {
color: black;
display: inline-block;
width: 100px; /*calculated*/
}
[data-im-insert="false"] {
caret-color: red;
caret-shape: block;
}

26
vendor/Inputmask/dist/bindings/inputmask.binding.js vendored
View File

@@ -1,26 +0,0 @@
/*
Input Mask plugin binding
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
(function (factory) {
factory(jQuery, window.Inputmask, window);
}
(function ($, Inputmask, window) {
$(window.document).ajaxComplete(function (event, xmlHttpRequest, ajaxOptions) {
if ($.inArray("html", ajaxOptions.dataTypes) !== -1) {
$(".inputmask, [data-inputmask], [data-inputmask-mask], [data-inputmask-alias], [data-inputmask-regex]").each(function (ndx, lmnt) {
if (lmnt.inputmask === undefined) {
Inputmask().mask(lmnt);
}
});
}
}).ready(function () {
$(".inputmask, [data-inputmask], [data-inputmask-mask], [data-inputmask-alias],[data-inputmask-regex]").each(function (ndx, lmnt) {
if (lmnt.inputmask === undefined) {
Inputmask().mask(lmnt);
}
});
});
}));

2468
vendor/Inputmask/dist/inputmask.js vendored
View File

File diff suppressed because it is too large Load Diff

8
vendor/Inputmask/dist/inputmask.min.js vendored
View File

File diff suppressed because one or more lines are too long

2407
vendor/Inputmask/dist/jquery.inputmask.js vendored
View File

File diff suppressed because it is too large Load Diff

8
vendor/Inputmask/dist/jquery.inputmask.min.js vendored
View File

File diff suppressed because one or more lines are too long

34
vendor/Inputmask/index.html vendored
View File

@@ -1,34 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link href="css/inputmask.css" rel="stylesheet" type="text/css">
</head>
<body>
<input id="test1" name="test1"/><br/>
<input id="test2" name="test2"/><br/>
<input id="test3" name="test3"/><br/>
<br/>
<script type="text/javascript" src="node_modules/jquery/dist/jquery.js" charset="utf-8"></script>
<script type="text/javascript" src="dist/jquery.inputmask.js" charset="utf-8"></script>
<script>
console.log(navigator.userAgent);
$("#test1").inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
outputFormat: "mm-yyyy-dd",
inputEventOnly: true
});
$("#test2").inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
outputFormat: "mm-yyyy-dd",
inputEventOnly: true
});
$("#test3").inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
outputFormat: "mm-yyyy-dd",
inputEventOnly: true
});
</script>
</body>
</html>

1
vendor/Inputmask/index.js vendored
View File

@@ -1 +0,0 @@
module.exports = require("./bundle");

26
vendor/Inputmask/lib/bindings/inputmask.binding.js vendored
View File

@@ -1,26 +0,0 @@
/*
Input Mask plugin binding
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
(function (factory) {
factory(jQuery, window.Inputmask, window);
}
(function ($, Inputmask, window) {
$(window.document).ajaxComplete(function (event, xmlHttpRequest, ajaxOptions) {
if ($.inArray("html", ajaxOptions.dataTypes) !== -1) {
$(".inputmask, [data-inputmask], [data-inputmask-mask], [data-inputmask-alias], [data-inputmask-regex]").each(function (ndx, lmnt) {
if (lmnt.inputmask === undefined) {
Inputmask().mask(lmnt);
}
});
}
}).ready(function () {
$(".inputmask, [data-inputmask], [data-inputmask-mask], [data-inputmask-alias],[data-inputmask-regex]").each(function (ndx, lmnt) {
if (lmnt.inputmask === undefined) {
Inputmask().mask(lmnt);
}
});
});
}));

170
vendor/Inputmask/lib/dependencyLibs/inputmask.dependencyLib.jqlite.js vendored
View File

@@ -1,170 +0,0 @@
/*
Input Mask plugin dependencyLib
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
var $ = require("jqlite"), window = require("../global/window"), document = window.document;
// Use a stripped-down indexOf as it's faster than native
// http://jsperf.com/thor-indexof-vs-for/5
function indexOf(list, elem) {
var i = 0,
len = list.length;
for (; i < len; i++) {
if (list[i] === elem) {
return i;
}
}
return -1;
}
function isWindow(obj) {
return obj != null && obj === obj.window;
}
function isArraylike(obj) {
// Support: iOS 8.2 (not reproducible in simulator)
// `in` check used to prevent JIT error (gh-2145)
// hasOwn isn't used here due to false negatives
// regarding Nodelist length in IE
var length = "length" in obj && obj.length,
ltype = typeof obj;
if (ltype === "function" || isWindow(obj)) {
return false;
}
if (obj.nodeType === 1 && length) {
return true;
}
return ltype === "array" || length === 0 ||
typeof length === "number" && length > 0 && (length - 1) in obj;
}
$.inArray = function (elem, arr, i) {
return arr == null ? -1 : indexOf(arr, elem, i);
};
$.isFunction = function (obj) {
return typeof obj === "function";
};
$.isArray = Array.isArray;
$.isPlainObject = function (obj) {
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
if (typeof obj !== "object" || obj.nodeType || isWindow(obj)) {
return false;
}
if (obj.constructor && !Object.hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf")) {
return false;
}
// If the function hasn't returned already, we're confident that
// |obj| is a plain object, created by {} or constructed with new Object
return true;
};
$.extend = function () {
var 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" && !$.isFunction(target)) {
target = {};
}
// Extend jQuery itself if only one argument is passed
if (i === length) {
target = this;
i--;
}
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 && ($.isPlainObject(copy) || (copyIsArray = $.isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && $.isArray(src) ? src : [];
} else {
clone = src && $.isPlainObject(src) ? 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;
};
$.each = function (obj, callback) {
var value, i = 0;
if (isArraylike(obj)) {
for (var length = obj.length; i < length; i++) {
value = callback.call(obj[i], i, obj[i]);
if (value === false) {
break;
}
}
} else {
for (i in obj) {
value = callback.call(obj[i], i, obj[i]);
if (value === false) {
break;
}
}
}
return obj;
};
$.data = function (elem, name, data) {
return $(elem).data(name, data);
};
$.Event = $.Event || function CustomEvent(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;
module.exports = $;

8
vendor/Inputmask/lib/dependencyLibs/inputmask.dependencyLib.jquery.js vendored
View File

@@ -1,8 +0,0 @@
/*
Input Mask plugin dependencyLib
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
module.exports = require("jquery");

372
vendor/Inputmask/lib/dependencyLibs/inputmask.dependencyLib.js vendored
View File

@@ -1,372 +0,0 @@
/*
Input Mask plugin dependencyLib
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
var window = require("../global/window"), document = window.document;
//helper functions
// Use a stripped-down indexOf as it's faster than native
// http://jsperf.com/thor-indexof-vs-for/5
function indexOf(list, elem) {
var i = 0,
len = list.length;
for (; i < len; i++) {
if (list[i] === elem) {
return i;
}
}
return -1;
}
function isWindow(obj) {
return obj != null && obj === obj["window"];
}
function isArraylike(obj) {
// Support: iOS 8.2 (not reproducible in simulator)
// `in` check used to prevent JIT error (gh-2145)
// hasOwn isn't used here due to false negatives
// regarding Nodelist length in IE
var length = "length" in obj && obj.length,
ltype = typeof obj;
if (ltype === "function" || isWindow(obj)) {
return false;
}
if (obj.nodeType === 1 && length) {
return true;
}
return ltype === "array" || length === 0 ||
typeof length === "number" && length > 0 && (length - 1) in obj;
}
function isValidElement(elem) {
return elem instanceof Element;
}
function DependencyLib(elem) {
if (elem instanceof DependencyLib) {
return elem;
}
if (!(this instanceof DependencyLib)) {
return new DependencyLib(elem);
}
if (elem !== undefined && elem !== null && elem !== window) {
this[0] = elem.nodeName ? elem : (elem[0] !== undefined && elem[0].nodeName ? elem[0] : document.querySelector(elem));
if (this[0] !== undefined && this[0] !== null) {
this[0].eventRegistry = this[0].eventRegistry || {};
}
}
}
DependencyLib.prototype = {
on: function (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;
},
off: function (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])) {
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;
},
trigger: function (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 {
evnt = new CustomEvent(ev, params);
} catch (e) {
evnt = document.createEvent("CustomEvent");
evnt.initCustomEvent(ev, params.bubbles, params.cancelable, params.detail);
}
if (events.type) DependencyLib.extend(evnt, events);
elem.dispatchEvent(evnt);
} else {
evnt = document.createEventObject();
evnt.eventType = ev;
evnt.detail = arguments[1];
if (events.type) DependencyLib.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;
}
};
//static
DependencyLib.isFunction = function (obj) {
return typeof obj === "function";
};
DependencyLib.noop = function () {
};
DependencyLib.isArray = Array.isArray;
DependencyLib.inArray = function (elem, arr, i) {
return arr == null ? -1 : indexOf(arr, elem, i);
};
DependencyLib.valHooks = undefined;
DependencyLib.isPlainObject = function (obj) {
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
if (typeof obj !== "object" || obj.nodeType || isWindow(obj)) {
return false;
}
if (obj.constructor && !Object.hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf")) {
return false;
}
// If the function hasn't returned already, we're confident that
// |obj| is a plain object, created by {} or constructed with new Object
return true;
};
DependencyLib.extend = function () {
var 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" && !DependencyLib.isFunction(target)) {
target = {};
}
// Extend jQuery itself if only one argument is passed
if (i === length) {
target = this;
i--;
}
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 && (DependencyLib.isPlainObject(copy) || (copyIsArray = DependencyLib.isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && DependencyLib.isArray(src) ? src : [];
} else {
clone = src && DependencyLib.isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
target[name] = DependencyLib.extend(deep, clone, copy);
// Don't bring in undefined values
} else if (copy !== undefined) {
target[name] = copy;
}
}
}
}
// Return the modified object
return target;
};
DependencyLib.each = function (obj, callback) {
var value, i = 0;
if (isArraylike(obj)) {
for (var length = obj.length; i < length; i++) {
value = callback.call(obj[i], i, obj[i]);
if (value === false) {
break;
}
}
} else {
for (i in obj) {
value = callback.call(obj[i], i, obj[i]);
if (value === false) {
break;
}
}
}
return obj;
};
DependencyLib.data = function (owner, key, value) {
if (value === undefined) {
return owner.__data ? owner.__data[key] : null;
} else {
owner.__data = owner.__data || {};
owner.__data[key] = value;
}
};
if (typeof window.CustomEvent === "function") {
DependencyLib.Event = window.CustomEvent;
} else {
DependencyLib.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;
};
DependencyLib.Event.prototype = window.Event.prototype;
}
module.exports = DependencyLib;

323
vendor/Inputmask/lib/extensions/inputmask.date.extensions.js vendored
View File

@@ -1,323 +0,0 @@
/*
Input Mask plugin extensions
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
var Inputmask = require("../inputmask"), $ = Inputmask.dependencyLib,
//supported codes for formatting
//http://blog.stevenlevithan.com/archives/date-time-format
//https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings?view=netframework-4.7
formatCode = { //regex, valueSetter, type, displayformatter
d: ["[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", Date.prototype.getDate], //Day of the month as digits; no leading zero for single-digit days.
dd: ["0[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", function () {
return pad(Date.prototype.getDate.call(this), 2);
}], //Day of the month as digits; leading zero for single-digit days.
ddd: [""], //Day of the week as a three-letter abbreviation.
dddd: [""], //Day of the week as its full name.
m: ["[1-9]|1[012]", Date.prototype.setMonth, "month", function () {
return Date.prototype.getMonth.call(this) + 1;
}], //Month as digits; no leading zero for single-digit months.
mm: ["0[1-9]|1[012]", Date.prototype.setMonth, "month", function () {
return pad(Date.prototype.getMonth.call(this) + 1, 2);
}], //Month as digits; leading zero for single-digit months.
mmm: [""], //Month as a three-letter abbreviation.
mmmm: [""], //Month as its full name.
yy: ["[0-9]{2}", Date.prototype.setFullYear, "year", function () {
return pad(Date.prototype.getFullYear.call(this), 2);
}], //Year as last two digits; leading zero for years less than 10.
yyyy: ["[0-9]{4}", Date.prototype.setFullYear, "year", function () {
return pad(Date.prototype.getFullYear.call(this), 4);
}],
h: ["[1-9]|1[0-2]", Date.prototype.setHours, "hours", Date.prototype.getHours], //Hours; no leading zero for single-digit hours (12-hour clock).
hh: ["0[1-9]|1[0-2]", Date.prototype.setHours, "hours", function () {
return pad(Date.prototype.getHours.call(this), 2);
}], //Hours; leading zero for single-digit hours (12-hour clock).
hhh: ["[0-9]+", Date.prototype.setHours, "hours", Date.prototype.getHours], //Hours; no limit
H: ["1?[0-9]|2[0-3]", Date.prototype.setHours, "hours", Date.prototype.getHours], //Hours; no leading zero for single-digit hours (24-hour clock).
HH: ["0[0-9]|1[0-9]|2[0-3]", Date.prototype.setHours, "hours", function () {
return pad(Date.prototype.getHours.call(this), 2);
}], //Hours; leading zero for single-digit hours (24-hour clock).
HHH: ["[0-9]+", Date.prototype.setHours, "hours", Date.prototype.getHours], //Hours; no limit
M: ["[1-5]?[0-9]", Date.prototype.setMinutes, "minutes", Date.prototype.getMinutes], //Minutes; no leading zero for single-digit minutes. Uppercase M unlike CF timeFormat's m to avoid conflict with months.
MM: ["0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setMinutes, "minutes", function () {
return pad(Date.prototype.getMinutes.call(this), 2);
}], //Minutes; leading zero for single-digit minutes. Uppercase MM unlike CF timeFormat's mm to avoid conflict with months.
s: ["[1-5]?[0-9]", Date.prototype.setSeconds, "seconds", Date.prototype.getSeconds], //Seconds; no leading zero for single-digit seconds.
ss: ["0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setSeconds, "seconds", function () {
return pad(Date.prototype.getSeconds.call(this), 2);
}], //Seconds; leading zero for single-digit seconds.
l: ["[0-9]{3}", Date.prototype.setMilliseconds, "milliseconds", function () {
return pad(Date.prototype.getMilliseconds.call(this), 3);
}], //Milliseconds. 3 digits.
L: ["[0-9]{2}", Date.prototype.setMilliseconds, "milliseconds", function () {
return pad(Date.prototype.getMilliseconds.call(this), 2);
}], //Milliseconds. 2 digits.
t: ["[ap]"], //Lowercase, single-character time marker string: a or p.
tt: ["[ap]m"], //two-character time marker string: am or pm.
T: ["[AP]"], //single-character time marker string: A or P.
TT: ["[AP]M"], //two-character time marker string: AM or PM.
Z: [""], //US timezone abbreviation, e.g. EST or MDT. With non-US timezones or in the Opera browser, the GMT/UTC offset is returned, e.g. GMT-0500
o: [""], //GMT/UTC timezone offset, e.g. -0500 or +0230.
S: [""] //The date's ordinal suffix (st, nd, rd, or th).
},
formatAlias = {
isoDate: "yyyy-mm-dd", //2007-06-09
isoTime: "HH:MM:ss", //17:46:21
isoDateTime: "yyyy-mm-dd'T'HH:MM:ss", //2007-06-09T17:46:21
isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'" //2007-06-09T22:46:21Z
};
function getTokenizer(opts) {
if (!opts.tokenizer) {
var tokens = [];
for (var ndx in formatCode) {
if (tokens.indexOf(ndx[0]) === -1) {
tokens.push(ndx[0]);
}
}
opts.tokenizer = "(" + tokens.join("+|") + ")+?|.";
opts.tokenizer = new RegExp(opts.tokenizer, "g");
}
return opts.tokenizer;
}
function isValidDate(dateParts, currentResult) {
return !isFinite(dateParts.rawday)
|| (dateParts.day == "29" && !isFinite(dateParts.rawyear))
|| new Date(dateParts.date.getFullYear(), isFinite(dateParts.rawmonth) ? dateParts.month : dateParts.date.getMonth() + 1, 0).getDate() >= dateParts.day
? currentResult
: false; //take corrective action if possible
}
function isDateInRange(dateParts, opts) {
var result = true;
if (opts.min) {
if (dateParts["rawyear"]) {
var rawYear = dateParts["rawyear"].replace(/[^0-9]/g, ""),
minYear = opts.min.year.substr(0, rawYear.length);
result = minYear <= rawYear;
}
if (dateParts["year"] === dateParts["rawyear"]) {
if (opts.min.date.getTime() === opts.min.date.getTime()) {
result = opts.min.date.getTime() <= dateParts.date.getTime();
}
}
}
if (result && opts.max && opts.max.date.getTime() === opts.max.date.getTime()) {
result = opts.max.date.getTime() >= dateParts.date.getTime();
}
return result;
}
//parse the given format and return a mask pattern
//when a dateObjValue is passed a datestring in the requested format is returned
function parse(format, dateObjValue, opts, raw) {
//parse format to regex string
var mask = "", match;
while ((match = getTokenizer(opts).exec(format))) {
if (dateObjValue === undefined) {
if (formatCode[match[0]]) {
mask += "(" + formatCode[match[0]][0] + ")";
} else {
switch (match[0]) {
case "[":
mask += "(";
break;
case "]":
mask += ")?";
break;
default:
mask += Inputmask.escapeRegex(match[0]);
}
}
} else {
if (formatCode[match[0]]) {
if (raw !== true && formatCode[match[0]][3]) {
var getFn = formatCode[match[0]][3];
mask += getFn.call(dateObjValue.date);
} else if (formatCode[match[0]][2]) {
mask += dateObjValue["raw" + formatCode[match[0]][2]];
} else {
mask += match[0];
}
} else {
mask += match[0];
}
}
}
return mask;
}
//padding function
function pad(val, len) {
val = String(val);
len = len || 2;
while (val.length < len) val = "0" + val;
return val;
}
function analyseMask(maskString, format, opts) {
var dateObj = {"date": new Date(1, 0, 1)}, targetProp, mask = maskString, match, dateOperation;
function extendProperty(value) {
var correctedValue = value.replace(/[^0-9]/g, "0");
// if (correctedValue != value) { //only do correction on incomplete values
// //determine best validation match
// var enteredPart = value.replace(/[^0-9]/g, ""),
// enteredPartIndex = value.indexOf(enteredPart),
// minPart = (opts.min && opts.min[targetProp] || value).slice(enteredPartIndex, enteredPartIndex + enteredPart.length),
// maxPart = (opts.max && opts.max[targetProp] || value).slice(enteredPartIndex, enteredPartIndex + enteredPart.length),
// correctedPart = enteredPart < minPart ? minPart : (enteredPart > maxPart ? maxPart : correctedValue.slice(enteredPartIndex, enteredPartIndex + enteredPart.length));
// correctedValue = correctedValue.split("");
// correctedValue.splice(enteredPartIndex, 1, correctedPart);
// correctedValue = correctedValue.join("");
// }
return correctedValue;
}
function setValue(dateObj, value, opts) {
dateObj[targetProp] = extendProperty(value);
dateObj["raw" + targetProp] = value;
if (dateOperation !== undefined) {
dateOperation.call(dateObj.date, targetProp == "month" ? parseInt(dateObj[targetProp]) - 1 : dateObj[targetProp]);
}
}
if (typeof mask === "string") {
while ((match = getTokenizer(opts).exec(format))) {
var value = mask.slice(0, match[0].length);
if (formatCode.hasOwnProperty(match[0])) {
// targetValidator = formatCode[match[0]][0];
targetProp = formatCode[match[0]][2];
dateOperation = formatCode[match[0]][1];
setValue(dateObj, value, opts);
}
mask = mask.slice(value.length);
}
return dateObj;
} else if (mask && typeof mask === "object" && mask.hasOwnProperty("date")) {
return mask;
}
return undefined;
}
Inputmask.extendAliases({
"datetime": {
mask: function (opts) {
//localize
formatCode.S = opts.i18n.ordinalSuffix.join("|");
opts.inputFormat = formatAlias[opts.inputFormat] || opts.inputFormat; //resolve possible formatAlias
opts.displayFormat = formatAlias[opts.displayFormat] || opts.displayFormat || opts.inputFormat; //resolve possible formatAlias
opts.outputFormat = formatAlias[opts.outputFormat] || opts.outputFormat || opts.inputFormat; //resolve possible formatAlias
opts.placeholder = opts.placeholder !== "" ? opts.placeholder : opts.inputFormat.replace(/[[\]]/, "");
opts.regex = parse(opts.inputFormat, undefined, opts);
// console.log(opts.regex);
return null; //migrate to regex mask
},
placeholder: "", //set default as none (~ auto); when a custom placeholder is passed it will be used
inputFormat: "isoDateTime", //format used to input the date
displayFormat: undefined, //visual format when the input looses focus
outputFormat: undefined, //unmasking format
min: null, //needs to be in the same format as the inputfornat
max: null, //needs to be in the same format as the inputfornat,
// Internationalization strings
i18n: {
dayNames: [
"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun",
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
],
monthNames: [
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
],
ordinalSuffix: ["st", "nd", "rd", "th"]
},
preValidation: function (buffer, pos, c, isSelection, opts, maskset) {
var calcPos = 0, targetMatch, match;
if (isNaN(c) && buffer[pos] !== c) {
while ((match = getTokenizer(opts).exec(opts.inputFormat))) {
calcPos += match[0].length;
if (calcPos >= pos) {
targetMatch = match;
match = getTokenizer(opts).exec(opts.inputFormat);
break;
}
}
if (match && match[0] === c && targetMatch[0].length > 1) {
buffer[pos] = buffer[pos - 1];
buffer[pos - 1] = "0";
return {
fuzzy: true,
buffer: buffer,
refreshFromBuffer: {start: pos - 1, end: pos + 1},
pos: pos + 1
};
}
}
return true;
},
postValidation: function (buffer, pos, currentResult, opts) {
opts.min = analyseMask(opts.min, opts.inputFormat, opts);
opts.max = analyseMask(opts.max, opts.inputFormat, opts);
if (currentResult.fuzzy) {
buffer = currentResult.buffer;
pos = currentResult.pos;
}
var result = currentResult, dateParts = analyseMask(buffer.join(""), opts.inputFormat, opts);
if (result && dateParts.date.getTime() === dateParts.date.getTime()) { //check for a valid date ~ an invalid date returns NaN which isn't equal
result = isValidDate(dateParts, result);
result = result && isDateInRange(dateParts, opts);
}
if (pos && result && currentResult.pos !== pos) {
return {
buffer: parse(opts.inputFormat, dateParts, opts),
refreshFromBuffer: {start: pos, end: currentResult.pos}
};
}
return result;
},
onKeyDown: function (e, buffer, caretPos, opts) {
var input = this;
if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
var today = new Date(), match, date = "";
while ((match = getTokenizer(opts).exec(opts.inputFormat))) {
if (match[0].charAt(0) === "d") {
date += pad(today.getDate(), match[0].length);
} else if (match[0].charAt(0) === "m") {
date += pad((today.getMonth() + 1), match[0].length);
} else if (match[0] === "yyyy") {
date += today.getFullYear().toString();
} else if (match[0].charAt(0) === "y") {
date += pad(today.getYear(), match[0].length);
}
}
input.inputmask._valueSet(date);
$(input).trigger("setvalue");
}
},
onUnMask: function (maskedValue, unmaskedValue, opts) {
return unmaskedValue ? parse(opts.outputFormat, analyseMask(maskedValue, opts.inputFormat, opts), opts, true) : unmaskedValue;
},
casing: function (elem, test, pos, validPositions) {
if (test.nativeDef.indexOf("[ap]") == 0) return elem.toLowerCase();
if (test.nativeDef.indexOf("[AP]") == 0) return elem.toUpperCase();
return elem;
},
insertMode: false,
shiftPositions: false
}
});
module.exports = Inputmask;

92
vendor/Inputmask/lib/extensions/inputmask.extensions.js vendored
View File

@@ -1,92 +0,0 @@
/*
Input Mask plugin extensions
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
var Inputmask = require("../inputmask");
//extra definitions
Inputmask.extendDefinitions({
"A": {
validator: "[A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]",
casing: "upper" //auto uppercasing
},
"&": { //alfanumeric uppercasing
validator: "[0-9A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]",
casing: "upper"
},
"#": { //hexadecimal
validator: "[0-9A-Fa-f]",
casing: "upper"
}
});
Inputmask.extendAliases({
"cssunit": {
regex: "[+-]?[0-9]+\\.?([0-9]+)?(px|em|rem|ex|%|in|cm|mm|pt|pc)"
},
"url": { //needs update => https://en.wikipedia.org/wiki/URL
regex: "(https?|ftp)//.*",
autoUnmask: false
},
"ip": { //ip-address mask
mask: "i[i[i]].i[i[i]].i[i[i]].i[i[i]]",
definitions: {
"i": {
validator: function (chrs, maskset, pos, strict, opts) {
if (pos - 1 > -1 && maskset.buffer[pos - 1] !== ".") {
chrs = maskset.buffer[pos - 1] + chrs;
if (pos - 2 > -1 && maskset.buffer[pos - 2] !== ".") {
chrs = maskset.buffer[pos - 2] + chrs;
} else chrs = "0" + chrs;
} else chrs = "00" + chrs;
return new RegExp("25[0-5]|2[0-4][0-9]|[01][0-9][0-9]").test(chrs);
}
}
},
onUnMask: function (maskedValue, unmaskedValue, opts) {
return maskedValue;
},
inputmode: "numeric",
},
"email": {
//https://en.wikipedia.org/wiki/Domain_name#Domain_name_space
//https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names
//should be extended with the toplevel domains at the end
mask: "*{1,64}[.*{1,64}][.*{1,64}][.*{1,63}]@-{1,63}.-{1,63}[.-{1,63}][.-{1,63}]",
greedy: false,
casing: "lower",
onBeforePaste: function (pastedValue, opts) {
pastedValue = pastedValue.toLowerCase();
return pastedValue.replace("mailto:", "");
},
definitions: {
"*": {
validator: "[0-9\uFF11-\uFF19A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5!#$%&'*+/=?^_`{|}~-]"
},
"-": {
validator: "[0-9A-Za-z-]"
}
},
onUnMask: function (maskedValue, unmaskedValue, opts) {
return maskedValue;
},
inputmode: "email"
},
"mac": {
mask: "##:##:##:##:##:##"
},
//https://en.wikipedia.org/wiki/Vehicle_identification_number
// see issue #1199
"vin": {
mask: "V{13}9{4}",
definitions: {
"V": {
validator: "[A-HJ-NPR-Za-hj-npr-z\\d]",
casing: "upper"
}
},
clearIncomplete: true,
autoUnmask: true
}
});
module.exports = Inputmask;

454
vendor/Inputmask/lib/extensions/inputmask.numeric.extensions.js vendored
View File

@@ -1,454 +0,0 @@
/*
Input Mask plugin extensions
http://github.com/RobinHerbots/jquery.inputmask
Copyright (c) Robin Herbots
Licensed under the MIT license
*/
var Inputmask = require("../inputmask"), $ = Inputmask.dependencyLib;
function autoEscape(txt, opts) {
var escapedTxt = "";
for (var i = 0; i < txt.length; i++) {
if (Inputmask.prototype.definitions[txt.charAt(i)] ||
opts.definitions[txt.charAt(i)] ||
opts.optionalmarker.start === txt.charAt(i) ||
opts.optionalmarker.end === txt.charAt(i) ||
opts.quantifiermarker.start === txt.charAt(i) ||
opts.quantifiermarker.end === txt.charAt(i) ||
opts.groupmarker.start === txt.charAt(i) ||
opts.groupmarker.end === txt.charAt(i) ||
opts.alternatormarker === txt.charAt(i)) {
escapedTxt += "\\" + txt.charAt(i);
} else {
escapedTxt += txt.charAt(i);
}
}
return escapedTxt;
}
function alignDigits(buffer, digits, opts) {
if (digits > 0 && !opts.digitsOptional && buffer.length > 0) {
var radixPosition = $.inArray(opts.radixPoint, buffer);
if (radixPosition === -1) {
buffer.push(opts.radixPoint);
radixPosition = buffer.length - 1;
}
for (var i = 1; i <= digits; i++) {
buffer[radixPosition + i] = buffer[radixPosition + i] || "0";
}
}
return buffer;
}
function findValidator(symbol, maskset) {
var posNdx = 0;
if (symbol === "+") {
for (posNdx in maskset.validPositions) ;
posNdx = parseInt(posNdx);
}
for (var tstNdx in maskset.tests) {
tstNdx = parseInt(tstNdx);
if (tstNdx >= posNdx) {
for (var ndx = 0, ndxl = maskset.tests[tstNdx].length; ndx < ndxl; ndx++) {
if ((maskset.validPositions[tstNdx] === undefined || symbol === "-") && maskset.tests[tstNdx][ndx].match.def === symbol) {
return tstNdx + ((maskset.validPositions[tstNdx] !== undefined && symbol !== "-") ? 1 : 0);
}
}
}
}
return posNdx;
}
function findValid(symbol, maskset) {
var ret = -1;
$.each(maskset.validPositions, function (ndx, tst) {
if (tst.match.def === symbol) {
ret = parseInt(ndx);
return false;
}
});
return ret;
}
function parseMinMaxOptions(opts) {
if (opts.parseMinMaxOptions === undefined) {
// convert min and max options
if (opts.min !== null) {
opts.min = opts.min.toString().replace(new RegExp(Inputmask.escapeRegex(opts.groupSeparator), "g"), "");
if (opts.radixPoint === ",") opts.min = opts.min.replace(opts.radixPoint, ".");
opts.min = isFinite(opts.min) ? parseFloat(opts.min) : NaN;
if (isNaN(opts.min)) opts.min = Number.MIN_VALUE;
}
if (opts.max !== null) {
opts.max = opts.max.toString().replace(new RegExp(Inputmask.escapeRegex(opts.groupSeparator), "g"), "");
if (opts.radixPoint === ",") opts.max = opts.max.replace(opts.radixPoint, ".");
opts.max = isFinite(opts.max) ? parseFloat(opts.max) : NaN;
if (isNaN(opts.max)) opts.max = Number.MAX_VALUE;
}
opts.parseMinMaxOptions = "done";
}
}
function genMask(opts) {
opts.repeat = 0;
//treat equal separator and radixpoint
if (opts.groupSeparator === opts.radixPoint && opts.digits && opts.digits !== "0") {
if (opts.radixPoint === ".") {
opts.groupSeparator = ",";
} else if (opts.radixPoint === ",") {
opts.groupSeparator = ".";
} else {
opts.groupSeparator = "";
}
}
//prevent conflict with default skipOptionalPartCharacter
if (opts.groupSeparator === " ") {
opts.skipOptionalPartCharacter = undefined;
}
//enforce placeholder to single
if (opts.placeholder.length > 1) {
opts.placeholder = opts.placeholder.charAt(0);
}
//only allow radixfocus when placeholder = 0
if (opts.positionCaretOnClick === "radixFocus" && opts.placeholder === "") {
opts.positionCaretOnClick = "lvp";
}
var decimalDef = "0";
if (opts.numericInput === true && opts.__financeInput === undefined) { //finance people input style
decimalDef = "1";
opts.positionCaretOnClick = opts.positionCaretOnClick === "radixFocus" ? "lvp" : opts.positionCaretOnClick;
// opts.digitsOptional = false;
if (isNaN(opts.digits)) opts.digits = 2;
opts._radixDance = false;
} else {
opts.__financeInput = false; //needed to keep original selection when remasking
opts.numericInput = true;
}
var mask = "[+]", altMask;
mask += autoEscape(opts.prefix, opts);
if (opts.groupSeparator !== "") {
mask += opts._mask(opts);
} else {
mask += "9{+}";
}
if (opts.digits !== undefined) {
var dq = opts.digits.toString().split(",");
if (isFinite(dq[0]) && dq[1] && isFinite(dq[1])) {
mask += opts.radixPoint + decimalDef + "{" + opts.digits + "}";
} else if (isNaN(opts.digits) || parseInt(opts.digits) > 0) {
if (opts.digitsOptional) {
altMask = mask + opts.radixPoint + decimalDef + "{0," + opts.digits + "}";
// mask += "[" + opts.radixPoint + "]";
opts.keepStatic = true;
} else {
mask += opts.radixPoint + decimalDef + "{" + opts.digits + "}";
}
}
}
mask += autoEscape(opts.suffix, opts);
mask += "[-]";
if (altMask) {
mask = [(altMask + autoEscape(opts.suffix, opts) + "[-]"), mask];
}
opts.greedy = false; //enforce greedy false
parseMinMaxOptions(opts);
return mask;
}
function hanndleRadixDance(pos, c, radixPos, opts) {
if (opts._radixDance && opts.numericInput && c !== opts.negationSymbol.back) {
if (pos <= radixPos && (radixPos > 0 || c == opts.radixPoint)) {
pos -= 1;
}
}
return pos;
}
function decimalValidator(chrs, maskset, pos, strict, opts) {
var radixPos = maskset.buffer.indexOf(opts.radixPoint),
result = radixPos !== -1 && new RegExp("[0-9\uFF11-\uFF19]").test(chrs);
if (opts._radixDance && result && maskset.validPositions[radixPos] == undefined) {
return {
insert: {
pos: radixPos === pos ? radixPos + 1 : radixPos,
c: opts.radixPoint
},
pos: pos
};
}
return result;
}
//number aliases
Inputmask.extendAliases({
"numeric": {
mask: genMask,
_mask: function (opts) {
return "(" + opts.groupSeparator + "999){+|1}";
},
placeholder: "0",
greedy: false,
digits: "*", //number of fractionalDigits
digitsOptional: true,
enforceDigitsOnBlur: false,
radixPoint: ".",
positionCaretOnClick: "radixFocus",
_radixDance: true,
groupSeparator: "",
allowMinus: true,
negationSymbol: {
front: "-", //"("
back: "" //")"
},
prefix: "",
suffix: "",
rightAlign: true,
min: null, //minimum value
max: null, //maximum value
step: 1,
insertMode: true,
autoUnmask: false,
unmaskAsNumber: false,
inputmode: "numeric",
definitions: {
"0": {
validator: decimalValidator
},
"1": {
validator: decimalValidator,
definitionSymbol: "*"
},
"+": {
validator: function (chrs, maskset, pos, strict, opts) {
return (opts.allowMinus && (chrs === "-" || chrs === opts.negationSymbol.front));
}
},
"-": {
validator: function (chrs, maskset, pos, strict, opts) {
return (opts.allowMinus && chrs === opts.negationSymbol.back);
}
}
},
preValidation: function (buffer, pos, c, isSelection, opts, maskset) {
var radixPos = $.inArray(opts.radixPoint, buffer);
pos = hanndleRadixDance(pos, c, radixPos, opts);
if (c === "-" || c === opts.negationSymbol.front) {
if (opts.allowMinus !== true) return false;
var isNegative = false,
front = findValid("+", maskset), back = findValid("-", maskset);
if (front !== -1) {
isNegative = [front, back];
}
return isNegative !== false ? {
remove: isNegative,
caret: radixPos > pos ? pos + 1 : pos
} : {
insert: [
{pos: findValidator("+", maskset), c: opts.negationSymbol.front, fromIsValid: true},
{pos: findValidator("-", maskset), c: opts.negationSymbol.back, fromIsValid: undefined}],
caret: radixPos > pos ? pos + 1 : pos
};
}
if (radixPos !== -1 && (opts._radixDance === true && isSelection === false && c === opts.radixPoint && (opts.digits !== undefined && (isNaN(opts.digits) || parseInt(opts.digits) > 0)) && radixPos !== pos)) {
return {
"caret": opts._radixDance && pos === radixPos - 1 ? radixPos + 1 : radixPos
};
}
return {rewritePosition: pos};
},
postValidation: function (buffer, pos, currentResult, opts) {
if (opts.min !== null || opts.max !== null) {
var unmasked = opts.onUnMask(buffer.slice().reverse().join(""), undefined, $.extend({}, opts, {
unmaskAsNumber: true
}));
if (opts.min !== null && unmasked < opts.min && unmasked.toString().length >= opts.min.toString().length) {
return false;
}
if (opts.max !== null && unmasked > opts.max) {
return false;
}
}
return currentResult;
},
onUnMask: function (maskedValue, unmaskedValue, opts) {
if (unmaskedValue === "" && opts.nullable === true) {
return unmaskedValue;
}
var processValue = maskedValue.replace(opts.prefix, "");
processValue = processValue.replace(opts.suffix, "");
processValue = processValue.replace(new RegExp(Inputmask.escapeRegex(opts.groupSeparator), "g"), "");
if (opts.placeholder.charAt(0) !== "") {
processValue = processValue.replace(new RegExp(opts.placeholder.charAt(0), "g"), "0");
}
if (opts.unmaskAsNumber) {
if (opts.radixPoint !== "" && processValue.indexOf(opts.radixPoint) !== -1) processValue = processValue.replace(Inputmask.escapeRegex.call(this, opts.radixPoint), ".");
processValue = processValue.replace(new RegExp("^" + Inputmask.escapeRegex(opts.negationSymbol.front)), "-");
processValue = processValue.replace(new RegExp(Inputmask.escapeRegex(opts.negationSymbol.back) + "$"), "");
return Number(processValue);
}
return processValue;
},
isComplete: function (buffer, opts) {
var maskedValue = (opts.numericInput ? buffer.slice().reverse() : buffer).join("");
maskedValue = maskedValue.replace(new RegExp("^" + Inputmask.escapeRegex(opts.negationSymbol.front)), "-");
maskedValue = maskedValue.replace(new RegExp(Inputmask.escapeRegex(opts.negationSymbol.back) + "$"), "");
maskedValue = maskedValue.replace(opts.prefix, "");
maskedValue = maskedValue.replace(opts.suffix, "");
maskedValue = maskedValue.replace(new RegExp(Inputmask.escapeRegex(opts.groupSeparator) + "([0-9]{3})", "g"), "$1");
if (opts.radixPoint === ",") maskedValue = maskedValue.replace(Inputmask.escapeRegex(opts.radixPoint), ".");
return isFinite(maskedValue);
},
onBeforeMask: function (initialValue, opts) {
var radixPoint = opts.radixPoint || ",";
if ((typeof initialValue == "number" || opts.inputType === "number") && radixPoint !== "") {
initialValue = initialValue.toString().replace(".", radixPoint);
}
var valueParts = initialValue.split(radixPoint),
integerPart = valueParts[0].replace(/[^\-0-9]/g, ""),
decimalPart = valueParts.length > 1 ? valueParts[1].replace(/[^0-9]/g, "") : "";
initialValue = integerPart + (decimalPart !== "" ? radixPoint + decimalPart : decimalPart);
var digits = 0;
if (radixPoint !== "") {
digits = decimalPart.length;
if (decimalPart !== "") {
var digitsFactor = Math.pow(10, digits || 1);
if (isFinite(opts.digits)) {
digits = parseInt(opts.digits);
digitsFactor = Math.pow(10, digits);
}
//make the initialValue a valid javascript number for the parsefloat
initialValue = initialValue.replace(Inputmask.escapeRegex(radixPoint), ".");
if (isFinite(initialValue)) {
initialValue = Math.round(parseFloat(initialValue) * digitsFactor) / digitsFactor;
}
initialValue = initialValue.toString().replace(".", radixPoint);
}
}
//this needs to be in a separate part and not directly in decimalPart to allow rounding
if (opts.digits === 0 && initialValue.indexOf(Inputmask.escapeRegex(radixPoint)) !== -1) {
initialValue = initialValue.substring(0, initialValue.indexOf(Inputmask.escapeRegex(radixPoint)));
}
return alignDigits(initialValue.toString().split(""), digits, opts).join("");
},
onBeforeWrite: function (e, buffer, caretPos, opts) {
var result;
//check leading zeros
var numberMatches = new RegExp("^" + (opts.negationSymbol.front != "" ? Inputmask.escapeRegex(opts.negationSymbol.front) + "?" : "") + Inputmask.escapeRegex(opts.prefix) + "(?<number>.*)" + Inputmask.escapeRegex(opts.suffix) + (opts.negationSymbol.back != "" ? Inputmask.escapeRegex(opts.negationSymbol.back) + "?" : "") + "$").exec(buffer.slice().reverse().join("")),
number = numberMatches ? numberMatches.groups.number : "";
if (false && number) {
number = number.split(opts.radixPoint.charAt(0))[0];
var leadingzeroes = new RegExp("^[0" + opts.groupSeparator + "]*").exec(number);
if (leadingzeroes[0].length > 1 || leadingzeroes[0].length > 0 && leadingzeroes[0].length < number.length) {
var buf = buffer.slice().reverse(), caretNdx = buf.join("").indexOf(leadingzeroes[0]);
buf.splice(caretNdx, leadingzeroes[0].length);
var newCaretPos = buf.length - caretNdx;
result = {
refreshFromBuffer: true,
buffer: buf.reverse(),
caret: caretPos < newCaretPos ? caretPos : newCaretPos
};
}
}
if (e) {
switch (e.type) {
case "blur":
case "checkval":
if (opts.radixPoint !== "" && buffer[0] === opts.radixPoint) {
if (result && result.buffer) {
result.buffer.shift();
} else {
buffer.shift();
result =
{refreshFromBuffer: true, buffer: buffer};
}
}
}
}
return result;
},
onKeyDown: function (e, buffer, caretPos, opts) {
var $input = $(this);
if (e.ctrlKey) {
switch (e.keyCode) {
case Inputmask.keyCode.UP:
this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) + parseInt(opts.step));
$input.trigger("setvalue");
return false;
case Inputmask.keyCode.DOWN:
this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) - parseInt(opts.step));
$input.trigger("setvalue");
return false;
}
}
if (e.keyCode === Inputmask.keyCode.DELETE || e.keyCode === Inputmask.keyCode.BACKSPACE || e.keyCode === Inputmask.keyCode.BACKSPACE_SAFARI) {
if (opts._radixDance === true && !opts.digitsOptional) {
var radixPos = $.inArray(opts.radixPoint, buffer);
if (radixPos !== -1 && (caretPos < radixPos || (e.keyCode === Inputmask.keyCode.DELETE && caretPos === radixPos))) {
if (e.keyCode === Inputmask.keyCode.BACKSPACE || e.keyCode === Inputmask.keyCode.BACKSPACE_SAFARI) {
caretPos++;
}
var bffr = buffer.slice().reverse();
bffr.splice(bffr.length - caretPos, 1);
$input.trigger("setvalue", [alignDigits(bffr, opts.digits, opts).join(""), caretPos]);
return false;
}
}
}
}
},
"currency": {
prefix: "$ ",
groupSeparator: ",",
alias: "numeric",
placeholder: "0",
digits: 2,
digitsOptional: false
},
"decimal": {
alias: "numeric"
},
"integer": {
alias: "numeric",
digits: 0
},
"percentage": {
alias: "integer",
min: 0,
max: 100,
suffix: " %",
allowMinus: false
},
"indianns": { //indian numbering system
alias: "numeric",
_mask: function (opts) {
return "(" + opts.groupSeparator + "99){*|1}(" + opts.groupSeparator + "999){1|1}";
},
groupSeparator: ",",
radixPoint: ".",
placeholder: "0",
digits: 2,
digitsOptional: false
}
});
module.exports = Inputmask;

7
vendor/Inputmask/lib/global/window.js vendored
View File

@@ -1,7 +0,0 @@
if (typeof define === "function" && define.amd)
define(function () {
return typeof window !== "undefined" ? window : new (eval("require('jsdom').JSDOM"))("").window;
});
else if (typeof exports === "object")
module.exports = typeof window !== "undefined" ? window : new (eval("require('jsdom').JSDOM"))("").window;

374
vendor/Inputmask/lib/inputmask.js vendored
View File

@@ -1,374 +0,0 @@
/*
* Input Mask Core
* http://github.com/RobinHerbots/jquery.inputmask
* Copyright (c) Robin Herbots
* Licensed under the MIT license
*/
var $ = require("./dependencyLibs/inputmask.dependencyLib"), window = require("./global/window"),
document = window.document,
generateMaskSet = require("./maskset").generateMaskSet,
analyseMask = require("./maskset").analyseMask,
maskScope = require("./maskScope");
function Inputmask(alias, options, internal) {
//allow instanciating without new
if (!(this instanceof Inputmask)) {
return new Inputmask(alias, options, internal);
}
this.el = undefined;
this.events = {};
this.maskset = undefined;
this.refreshValue = false; //indicate a refresh from the inputvalue is needed (form.reset)
if (internal !== true) {
//init options
if ($.isPlainObject(alias)) {
options = alias;
} else {
options = options || {};
if (alias) options.alias = alias;
}
this.opts = $.extend(true, {}, this.defaults, options);
this.noMasksCache = options && options.definitions !== undefined;
this.userOptions = options || {}; //user passed options
resolveAlias(this.opts.alias, options, this.opts);
this.isRTL = this.opts.numericInput;
}
}
Inputmask.prototype = {
dataAttribute: "data-inputmask", //data attribute prefix used for attribute binding
//options default
defaults: {
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: $.noop, //executes when the mask is complete
onincomplete: $.noop, //executes when the mask is incomplete and focus is lost
oncleared: $.noop, //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
clearIncomplete: false, //clear the incomplete input on blur
alias: null,
onKeyDown: $.noop, //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 $.isFunction(opts.onBeforeMask) ? 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: $.noop, //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 - null see auto selection for multi masks
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: [8, 9, 13, 19, 27, 33, 34, 35, 36, 37, 38, 39, 40, 45, 46, 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 => 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, currentResult, opts => 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: "verbatim", //specify the inputmode - already in place for when browsers will support it
colorMask: false, //enable css styleable mask
disablePredictiveText: false, //disable Predictive Text on mobile devices
importDataAttributes: true, //import data-inputmask attributes
shiftPositions: true //shift position of the mask entries on entry and deletion.
},
definitions: {
"9": { //\uFF11-\uFF19 #1606
validator: "[0-9\uFF11-\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\uFF11-\uFF19A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]"
}
},
aliases: {}, //aliases definitions
masksCache: {},
mask: function (elems) {
var that = this;
if (typeof elems === "string") {
elems = document.getElementById(elems) || document.querySelectorAll(elems);
}
elems = elems.nodeName ? [elems] : elems;
$.each(elems, function (ndx, el) {
var scopedOpts = $.extend(true, {}, that.opts);
if (importAttributeOptions(el, scopedOpts, $.extend(true, {}, that.userOptions), that.dataAttribute)) {
var maskset = generateMaskSet(scopedOpts, that.noMasksCache);
if (maskset !== undefined) {
if (el.inputmask !== undefined) {
el.inputmask.opts.autoUnmask = true; //force autounmasking when remasking
el.inputmask.remove();
}
//store inputmask instance on the input with element reference
el.inputmask = new Inputmask(undefined, undefined, true);
el.inputmask.opts = scopedOpts;
el.inputmask.noMasksCache = that.noMasksCache;
el.inputmask.userOptions = $.extend(true, {}, that.userOptions);
el.inputmask.isRTL = scopedOpts.isRTL || scopedOpts.numericInput;
el.inputmask.el = el;
el.inputmask.maskset = maskset;
$.data(el, "_inputmask_opts", scopedOpts);
maskScope.call(el.inputmask, {
"action": "mask"
});
}
}
});
return elems && elems[0] ? (elems[0].inputmask || this) : this;
},
option: function (options, noremask) { //set extra options || retrieve value of a current option
if (typeof options === "string") {
return this.opts[options];
} else if (typeof options === "object") {
$.extend(this.userOptions, options); //user passed options
//remask
if (this.el && noremask !== true) {
this.mask(this.el);
}
return this;
}
},
unmaskedvalue: function (value) {
this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
return maskScope.call(this, {
"action": "unmaskedvalue",
"value": value
});
},
remove: function () {
return maskScope.call(this, {
"action": "remove"
});
},
getemptymask: function () { //return the default (empty) mask value, usefull for setting the default value in validation
this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
return maskScope.call(this, {
"action": "getemptymask"
});
},
hasMaskedValue: function () { //check wheter the returned value is masked or not; currently only works reliable when using jquery.val fn to retrieve the value
return !this.opts.autoUnmask;
},
isComplete: function () {
this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
return maskScope.call(this, {
"action": "isComplete"
});
},
getmetadata: function () { //return mask metadata if exists
this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
return maskScope.call(this, {
"action": "getmetadata"
});
},
isValid: function (value) {
this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
return maskScope.call(this, {
"action": "isValid",
"value": value
});
},
format: function (value, metadata) {
this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
return maskScope.call(this, {
"action": "format",
"value": value,
"metadata": metadata //true/false getmetadata
});
},
setValue: function (value) {
if (this.el) {
$(this.el).trigger("setvalue", [value]);
}
},
analyseMask: analyseMask,
positionColorMask: function (input, template) {
input.style.left = template.offsetLeft + "px";
}
};
function resolveAlias(aliasStr, options, opts) {
var aliasDefinition = Inputmask.prototype.aliases[aliasStr];
if (aliasDefinition) {
if (aliasDefinition.alias) resolveAlias(aliasDefinition.alias, undefined, opts); //alias is another alias
$.extend(true, opts, aliasDefinition); //merge alias definition in the options
$.extend(true, opts, options); //reapply extra given options
return true;
} else //alias not found - try as mask
if (opts.mask === null) {
opts.mask = aliasStr;
}
return false;
}
function importAttributeOptions(npt, opts, userOptions, dataAttribute) {
function importOption(option, optionData) {
optionData = optionData !== undefined ? optionData : npt.getAttribute(dataAttribute + "-" + option);
if (optionData !== null) {
if (typeof optionData === "string") {
if (option.indexOf("on") === 0) {
optionData = window[optionData];
}//get function definition
else if (optionData === "false") {
optionData = false;
} else if (optionData === "true") optionData = true;
}
userOptions[option] = optionData;
}
}
if (opts.importDataAttributes === true) {
var attrOptions = npt.getAttribute(dataAttribute), option, dataoptions, optionData, p;
if (attrOptions && attrOptions !== "") {
attrOptions = attrOptions.replace(/'/g, "\"");
dataoptions = JSON.parse("{" + attrOptions + "}");
}
//resolve aliases
if (dataoptions) { //pickup alias from dataAttribute
optionData = undefined;
for (p in dataoptions) {
if (p.toLowerCase() === "alias") {
optionData = dataoptions[p];
break;
}
}
}
importOption("alias", optionData); //pickup alias from dataAttribute-alias
if (userOptions.alias) {
resolveAlias(userOptions.alias, userOptions, opts);
}
for (option in opts) {
if (dataoptions) {
optionData = undefined;
for (p in dataoptions) {
if (p.toLowerCase() === option.toLowerCase()) {
optionData = dataoptions[p];
break;
}
}
}
importOption(option, optionData);
}
}
$.extend(true, opts, userOptions);
//handle dir=rtl
if (npt.dir === "rtl" || opts.rightAlign) {
npt.style.textAlign = "right";
}
if (npt.dir === "rtl" || opts.numericInput) {
npt.dir = "ltr";
npt.removeAttribute("dir");
opts.isRTL = true;
}
return Object.keys(userOptions).length;
}
//apply defaults, definitions, aliases
Inputmask.extendDefaults = function (options) {
$.extend(true, Inputmask.prototype.defaults, options);
};
Inputmask.extendDefinitions = function (definition) {
$.extend(true, Inputmask.prototype.definitions, definition);
};
Inputmask.extendAliases = function (alias) {
$.extend(true, Inputmask.prototype.aliases, alias);
};
//static fn on inputmask
Inputmask.format = function (value, options, metadata) {
return Inputmask(options).format(value, metadata);
};
Inputmask.unmask = function (value, options) {
return Inputmask(options).unmaskedvalue(value);
};
Inputmask.isValid = function (value, options) {
return Inputmask(options).isValid(value);
};
Inputmask.remove = function (elems) {
if (typeof elems === "string") {
elems = document.getElementById(elems) || document.querySelectorAll(elems);
}
elems = elems.nodeName ? [elems] : elems;
$.each(elems, function (ndx, el) {
if (el.inputmask) el.inputmask.remove();
});
};
Inputmask.setValue = function (elems, value) {
if (typeof elems === "string") {
elems = document.getElementById(elems) || document.querySelectorAll(elems);
}
elems = elems.nodeName ? [elems] : elems;
$.each(elems, function (ndx, el) {
if (el.inputmask) el.inputmask.setValue(value); else $(el).trigger("setvalue", [value]);
});
};
Inputmask.escapeRegex = function (str) {
var specials = ["/", ".", "*", "+", "?", "|", "(", ")", "[", "]", "{", "}", "\\", "$", "^"];
return str.replace(new RegExp("(\\" + specials.join("|\\") + ")", "gim"), "\\$1");
};
Inputmask.keyCode = {
BACKSPACE: 8,
BACKSPACE_SAFARI: 127,
DELETE: 46,
DOWN: 40,
END: 35,
ENTER: 13,
ESCAPE: 27,
HOME: 36,
INSERT: 45,
LEFT: 37,
PAGE_DOWN: 34,
PAGE_UP: 33,
RIGHT: 39,
SPACE: 32,
TAB: 9,
UP: 38,
X: 88,
CONTROL: 17
};
Inputmask.dependencyLib = $;
//make inputmask available
window.Inputmask = Inputmask;
module.exports = Inputmask;

79
vendor/Inputmask/lib/jquery.inputmask.js vendored
View File

@@ -1,79 +0,0 @@
/*
* Input Mask plugin for jquery
* http://github.com/RobinHerbots/jquery.inputmask
* Copyright (c) Robin Herbots
* Licensed under the MIT license
*/
var $ = require("jquery"), Inputmask = require("./inputmask");
if ($.fn.inputmask === undefined) {
//jquery plugin
$.fn.inputmask = function (fn, options) {
var nptmask, input = this[0];
if (options === undefined) options = {};
if (typeof fn === "string") {
switch (fn) {
case "unmaskedvalue":
return input && input.inputmask ? input.inputmask.unmaskedvalue() : $(input).val();
case "remove":
return this.each(function () {
if (this.inputmask) this.inputmask.remove();
});
case "getemptymask":
return input && input.inputmask ? input.inputmask.getemptymask() : "";
case "hasMaskedValue": //check whether the returned value is masked or not; currently only works reliable when using jquery.val fn to retrieve the value
return input && input.inputmask ? input.inputmask.hasMaskedValue() : false;
case "isComplete":
return input && input.inputmask ? input.inputmask.isComplete() : true;
case "getmetadata": //return mask metadata if exists
return input && input.inputmask ? input.inputmask.getmetadata() : undefined;
case "setvalue":
Inputmask.setValue(input, options);
break;
case "option":
if (typeof options === "string") {
if (input && input.inputmask !== undefined) {
return input.inputmask.option(options);
}
} else {
return this.each(function () {
if (this.inputmask !== undefined) {
return this.inputmask.option(options);
}
});
}
break;
default:
options.alias = fn;
nptmask = new Inputmask(options);
return this.each(function () {
nptmask.mask(this);
});
}
} else if (Array.isArray(fn)) {
options.alias = fn;
nptmask = new Inputmask(options);
return this.each(function () {
nptmask.mask(this);
});
} else if (typeof fn == "object") {
nptmask = new Inputmask(fn);
if (fn.mask === undefined && fn.alias === undefined) {
return this.each(function () {
if (this.inputmask !== undefined) {
return this.inputmask.option(fn);
} else nptmask.mask(this);
});
} else {
return this.each(function () {
nptmask.mask(this);
});
}
} else if (fn === undefined) {
//look for data-inputmask atributes
return this.each(function () {
nptmask = new Inputmask(options);
nptmask.mask(this);
});
}
};
}

2527
vendor/Inputmask/lib/maskScope.js vendored
View File

File diff suppressed because it is too large Load Diff

471
vendor/Inputmask/lib/maskset.js vendored
View File

@@ -1,471 +0,0 @@
var $ = require("./dependencyLibs/inputmask.dependencyLib");
function generateMaskSet(opts, nocache) {
var ms;
function generateMask(mask, metadata, opts) {
var regexMask = false;
if (mask === null || mask === "") {
regexMask = opts.regex !== null;
if (regexMask) {
mask = opts.regex;
mask = mask.replace(/^(\^)(.*)(\$)$/, "$2");
} else {
regexMask = true;
mask = ".*";
}
}
if (mask.length === 1 && opts.greedy === false && opts.repeat !== 0) {
opts.placeholder = "";
} //hide placeholder with single non-greedy mask
if (opts.repeat > 0 || opts.repeat === "*" || opts.repeat === "+") {
var repeatStart = opts.repeat === "*" ? 0 : (opts.repeat === "+" ? 1 : opts.repeat);
mask = opts.groupmarker[0] + mask + opts.groupmarker[1] + opts.quantifiermarker[0] + repeatStart + "," + opts.repeat + opts.quantifiermarker[1];
}
// console.log(mask);
var masksetDefinition, maskdefKey;
maskdefKey = regexMask ? "regex_" + opts.regex : opts.numericInput ? mask.split("").reverse().join("") : mask;
if (opts.keepStatic !== false) { //keepstatic modifies the output from the testdefinitions ~ so differentiate in the maskcache
maskdefKey = "ks_" + maskdefKey;
}
if (Inputmask.prototype.masksCache[maskdefKey] === undefined || nocache === true) {
masksetDefinition = {
"mask": mask,
"maskToken": Inputmask.prototype.analyseMask(mask, regexMask, opts),
"validPositions": {},
"_buffer": undefined,
"buffer": undefined,
"tests": {},
"excludes": {}, //excluded alternations
"metadata": metadata,
"maskLength": undefined,
"jitOffset": {}
};
if (nocache !== true) {
Inputmask.prototype.masksCache[maskdefKey] = masksetDefinition;
masksetDefinition = $.extend(true, {}, Inputmask.prototype.masksCache[maskdefKey]);
}
} else {
masksetDefinition = $.extend(true, {}, Inputmask.prototype.masksCache[maskdefKey]);
}
return masksetDefinition;
}
if ($.isFunction(opts.mask)) { //allow mask to be a preprocessing fn - should return a valid mask
opts.mask = opts.mask(opts);
}
if ($.isArray(opts.mask)) {
if (opts.mask.length > 1) {
if (opts.keepStatic === null) { //enable by default when passing multiple masks when the option is not explicitly specified
opts.keepStatic = "auto";
for (var i = 0; i < opts.mask.length; i++) {
if (opts.mask[i].charAt(0) !== opts.mask[0].charAt(0)) {
opts.keepStatic = true;
break;
}
}
}
var altMask = opts.groupmarker[0];
$.each(opts.isRTL ? opts.mask.reverse() : opts.mask, function (ndx, msk) {
if (altMask.length > 1) {
altMask += opts.groupmarker[1] + opts.alternatormarker + opts.groupmarker[0];
}
if (msk.mask !== undefined && !$.isFunction(msk.mask)) {
altMask += msk.mask;
} else {
altMask += msk;
}
});
altMask += opts.groupmarker[1];
// console.log(altMask);
return generateMask(altMask, opts.mask, opts);
} else {
opts.mask = opts.mask.pop();
}
}
if (opts.mask && opts.mask.mask !== undefined && !$.isFunction(opts.mask.mask)) {
ms = generateMask(opts.mask.mask, opts.mask, opts);
} else {
ms = generateMask(opts.mask, opts.mask, opts);
}
return ms;
}
function analyseMask(mask, regexMask, opts) {
var tokenizer = /(?:[?*+]|\{[0-9+*]+(?:,[0-9+*]*)?(?:\|[0-9+*]*)?\})|[^.?*+^${[]()|\\]+|./g,
//Thx to https://github.com/slevithan/regex-colorizer for the regexTokenizer regex
regexTokenizer = /\[\^?]?(?:[^\\\]]+|\\[\S\s]?)*]?|\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9][0-9]*|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|c[A-Za-z]|[\S\s]?)|\((?:\?[:=!]?)?|(?:[?*+]|\{[0-9]+(?:,[0-9]*)?\})\??|[^.?*+^${[()|\\]+|./g,
escaped = false,
currentToken = new MaskToken(),
match,
m,
openenings = [],
maskTokens = [],
openingToken,
currentOpeningToken,
alternator,
lastMatch,
closeRegexGroup = false;
function MaskToken(isGroup, isOptional, isQuantifier, isAlternator) {
this.matches = [];
this.openGroup = isGroup || false;
this.alternatorGroup = false;
this.isGroup = isGroup || false;
this.isOptional = isOptional || false;
this.isQuantifier = isQuantifier || false;
this.isAlternator = isAlternator || false;
this.quantifier = {
min: 1,
max: 1
};
}
//test definition => {fn: RegExp/function, static: true/false optionality: bool, newBlockMarker: bool, casing: null/upper/lower, def: definitionSymbol, placeholder: placeholder, mask: real maskDefinition}
function insertTestDefinition(mtoken, element, position) {
position = position !== undefined ? position : mtoken.matches.length;
var prevMatch = mtoken.matches[position - 1];
if (regexMask) {
if (element.indexOf("[") === 0 || (escaped && /\\d|\\s|\\w]/i.test(element)) || element === ".") {
mtoken.matches.splice(position++, 0, {
fn: new RegExp(element, opts.casing ? "i" : ""),
static: false,
optionality: false,
newBlockMarker: prevMatch === undefined ? "master" : prevMatch.def !== element,
casing: null,
def: element,
placeholder: undefined,
nativeDef: element
});
} else {
if (escaped) element = element[element.length - 1];
$.each(element.split(""), function (ndx, lmnt) {
prevMatch = mtoken.matches[position - 1];
mtoken.matches.splice(position++, 0, {
fn: /[a-z]/i.test((opts.staticDefinitionSymbol || lmnt)) ? new RegExp("[" + (opts.staticDefinitionSymbol || lmnt) + "]", opts.casing ? "i" : "") : null,
static: true,
optionality: false,
newBlockMarker: prevMatch === undefined ? "master" : (prevMatch.def !== lmnt && prevMatch.static !== true),
casing: null,
def: opts.staticDefinitionSymbol || lmnt,
placeholder: opts.staticDefinitionSymbol !== undefined ? lmnt : undefined,
nativeDef: (escaped ? "'" : "") + lmnt
});
});
}
escaped = false;
} else {
var maskdef = (opts.definitions ? opts.definitions[element] : undefined) || Inputmask.prototype.definitions[element];
if (maskdef && !escaped) {
mtoken.matches.splice(position++, 0, {
fn: maskdef.validator ? typeof maskdef.validator == "string" ? new RegExp(maskdef.validator, opts.casing ? "i" : "") : new function () {
this.test = maskdef.validator;
} : new RegExp("."),
static: false,
optionality: false,
newBlockMarker: prevMatch === undefined ? "master" : prevMatch.def !== (maskdef.definitionSymbol || element),
casing: maskdef.casing,
def: maskdef.definitionSymbol || element,
placeholder: maskdef.placeholder,
nativeDef: element
});
} else {
mtoken.matches.splice(position++, 0, {
fn: /[a-z]/i.test((opts.staticDefinitionSymbol || element)) ? new RegExp("[" + (opts.staticDefinitionSymbol || element) + "]", opts.casing ? "i" : "") : null,
static: true,
optionality: false,
newBlockMarker: prevMatch === undefined ? "master" : (prevMatch.def !== element && prevMatch.static !== true),
casing: null,
def: opts.staticDefinitionSymbol || element,
placeholder: opts.staticDefinitionSymbol !== undefined ? element : undefined,
nativeDef: (escaped ? "'" : "") + element
});
escaped = false;
}
}
}
function verifyGroupMarker(maskToken) {
if (maskToken && maskToken.matches) {
$.each(maskToken.matches, function (ndx, token) {
var nextToken = maskToken.matches[ndx + 1];
if ((nextToken === undefined || (nextToken.matches === undefined || nextToken.isQuantifier === false)) && token && token.isGroup) { //this is not a group but a normal mask => convert
token.isGroup = false;
if (!regexMask) {
insertTestDefinition(token, opts.groupmarker[0], 0);
if (token.openGroup !== true) {
insertTestDefinition(token, opts.groupmarker[1]);
}
}
}
verifyGroupMarker(token);
});
}
}
function defaultCase() {
if (openenings.length > 0) {
currentOpeningToken = openenings[openenings.length - 1];
insertTestDefinition(currentOpeningToken, m);
if (currentOpeningToken.isAlternator) { //handle alternator a | b case
alternator = openenings.pop();
for (var mndx = 0; mndx < alternator.matches.length; mndx++) {
if (alternator.matches[mndx].isGroup) alternator.matches[mndx].isGroup = false; //don't mark alternate groups as group
}
if (openenings.length > 0) {
currentOpeningToken = openenings[openenings.length - 1];
currentOpeningToken.matches.push(alternator);
} else {
currentToken.matches.push(alternator);
}
}
} else {
insertTestDefinition(currentToken, m);
}
}
function reverseTokens(maskToken) {
function reverseStatic(st) {
if (st === opts.optionalmarker[0]) {
st = opts.optionalmarker[1];
} else if (st === opts.optionalmarker[1]) {
st = opts.optionalmarker[0];
} else if (st === opts.groupmarker[0]) {
st = opts.groupmarker[1];
} else if (st === opts.groupmarker[1]) st = opts.groupmarker[0];
return st;
}
maskToken.matches = maskToken.matches.reverse();
for (var match in maskToken.matches) {
if (maskToken.matches.hasOwnProperty(match)) {
var intMatch = parseInt(match);
if (maskToken.matches[match].isQuantifier && maskToken.matches[intMatch + 1] && maskToken.matches[intMatch + 1].isGroup) { //reposition quantifier
var qt = maskToken.matches[match];
maskToken.matches.splice(match, 1);
maskToken.matches.splice(intMatch + 1, 0, qt);
}
if (maskToken.matches[match].matches !== undefined) {
maskToken.matches[match] = reverseTokens(maskToken.matches[match]);
} else {
maskToken.matches[match] = reverseStatic(maskToken.matches[match]);
}
}
}
return maskToken;
}
function groupify(matches) {
var groupToken = new MaskToken(true);
groupToken.openGroup = false;
groupToken.matches = matches;
return groupToken;
}
function closeGroup() {
// Group closing
openingToken = openenings.pop();
openingToken.openGroup = false; //mark group as complete
if (openingToken !== undefined) {
if (openenings.length > 0) {
currentOpeningToken = openenings[openenings.length - 1];
currentOpeningToken.matches.push(openingToken);
if (currentOpeningToken.isAlternator) { //handle alternator (a) | (b) case
alternator = openenings.pop();
for (var mndx = 0; mndx < alternator.matches.length; mndx++) {
alternator.matches[mndx].isGroup = false; //don't mark alternate groups as group
alternator.matches[mndx].alternatorGroup = false;
}
if (openenings.length > 0) {
currentOpeningToken = openenings[openenings.length - 1];
currentOpeningToken.matches.push(alternator);
} else {
currentToken.matches.push(alternator);
}
}
} else {
currentToken.matches.push(openingToken);
}
} else {
defaultCase();
}
}
function groupQuantifier(matches) {
var lastMatch = matches.pop();
if (lastMatch.isQuantifier) {
lastMatch = groupify([matches.pop(), lastMatch]);
}
return lastMatch;
}
if (regexMask) {
opts.optionalmarker[0] = undefined;
opts.optionalmarker[1] = undefined;
}
while ((match = regexMask ? regexTokenizer.exec(mask) : tokenizer.exec(mask))) {
m = match[0];
if (regexMask) {
switch (m.charAt(0)) {
//Quantifier
case "?":
m = "{0,1}";
break;
case "+":
case "*":
m = "{" + m + "}";
break;
case "|":
//regex mask alternator ex: [01][0-9]|2[0-3] => ([01][0-9]|2[0-3])
if (openenings.length === 0) { //wrap the mask in a group to form a regex alternator ([01][0-9]|2[0-3])
var altRegexGroup = groupify(currentToken.matches);
altRegexGroup.openGroup = true;
openenings.push(altRegexGroup);
currentToken.matches = [];
closeRegexGroup = true;
}
break;
}
}
if (escaped) {
defaultCase();
continue;
}
switch (m.charAt(0)) {
case "(?=": //lookahead
break;
case "(?!": //negative lookahead
break;
case "(?<=": //lookbehind
break;
case "(?<!": //negative lookbehind
break;
case opts.escapeChar:
escaped = true;
if (regexMask) {
defaultCase();
}
break;
// optional closing
case opts.optionalmarker[1]:
case opts.groupmarker[1]:
closeGroup();
break;
case opts.optionalmarker[0]:
// optional opening
openenings.push(new MaskToken(false, true));
break;
case opts.groupmarker[0]:
// Group opening
openenings.push(new MaskToken(true));
break;
case opts.quantifiermarker[0]:
//Quantifier
var quantifier = new MaskToken(false, false, true);
m = m.replace(/[{}]/g, "");
var mqj = m.split("|"),
mq = mqj[0].split(","),
mq0 = isNaN(mq[0]) ? mq[0] : parseInt(mq[0]),
mq1 = mq.length === 1 ? mq0 : (isNaN(mq[1]) ? mq[1] : parseInt(mq[1]));
if (mq0 === "*" || mq0 === "+") {
mq0 = mq1 === "*" ? 0 : 1;
}
quantifier.quantifier = {
min: mq0,
max: mq1,
jit: mqj[1]
};
var matches = openenings.length > 0 ? openenings[openenings.length - 1].matches : currentToken.matches;
match = matches.pop();
if (match.isAlternator) { //handle quantifier in an alternation [0-9]{2}|[0-9]{3}
matches.push(match); //push back alternator
matches = match.matches; //remap target matches
var groupToken = new MaskToken(true);
var tmpMatch = matches.pop();
matches.push(groupToken); //push the group
matches = groupToken.matches;
match = tmpMatch;
}
if (!match.isGroup) {
// if (regexMask && match.fn === null) { //why is this needed???
// if (match.def === ".") match.fn = new RegExp(match.def, opts.casing ? "i" : "");
// }
match = groupify([match]);
}
matches.push(match);
matches.push(quantifier);
break;
case opts.alternatormarker:
if (openenings.length > 0) {
currentOpeningToken = openenings[openenings.length - 1];
var subToken = currentOpeningToken.matches[currentOpeningToken.matches.length - 1];
if (currentOpeningToken.openGroup && //regexp alt syntax
(subToken.matches === undefined || (subToken.isGroup === false && subToken.isAlternator === false))) { //alternations within group
lastMatch = openenings.pop();
} else {
lastMatch = groupQuantifier(currentOpeningToken.matches);
}
} else {
lastMatch = groupQuantifier(currentToken.matches);
}
if (lastMatch.isAlternator) {
openenings.push(lastMatch);
} else {
if (lastMatch.alternatorGroup) {
alternator = openenings.pop();
lastMatch.alternatorGroup = false;
} else {
alternator = new MaskToken(false, false, false, true);
}
alternator.matches.push(lastMatch);
openenings.push(alternator);
if (lastMatch.openGroup) { //regexp alt syntax
lastMatch.openGroup = false;
var alternatorGroup = new MaskToken(true);
alternatorGroup.alternatorGroup = true;
openenings.push(alternatorGroup);
}
}
break;
default:
defaultCase();
}
}
if (closeRegexGroup) closeGroup();
while (openenings.length > 0) {
openingToken = openenings.pop();
currentToken.matches.push(openingToken);
}
if (currentToken.matches.length > 0) {
verifyGroupMarker(currentToken);
maskTokens.push(currentToken);
}
if (opts.numericInput || opts.isRTL) {
reverseTokens(maskTokens[0]);
}
// console.log(JSON.stringify(maskTokens));
return maskTokens;
}
module.exports = {
generateMaskSet: generateMaskSet,
analyseMask: analyseMask
};

20
vendor/Inputmask/nuspecs/Inputmask.nuspec vendored
View File

@@ -1,20 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
<metadata>
<id>inputmask</id>
<version>0.0.0</version>
<title>Inputmask</title>
<authors>Robin Herbots</authors>
<owners>Robin Herbots</owners>
<licenseUrl>https://github.com/RobinHerbots/Inputmask/blob/4.x/LICENSE.txt</licenseUrl>
<projectUrl>https://github.com/RobinHerbots/Inputmask</projectUrl>
<requireLicenseAcceptance>true</requireLicenseAcceptance>
<description>Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.</description>
<summary>Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.</summary>
<tags>jQuery, plugins, input, form, inputmask, mask</tags>
</metadata>
<files>
<file src="..\dist\**\*" target="content\Scripts\inputmask" />
<file src="Readme.txt" target="Readme.txt" />
</files>
</package>

12
vendor/Inputmask/nuspecs/Readme.txt vendored
View File

@@ -1,12 +0,0 @@
## .NET Nuget Package Install
PM> Install-Package InputMask
In App_Start, BundleConfig.cs
bundles.Add(new ScriptBundle("~/bundles/inputmask").Include(
"~/Scripts/inputmask/jquery.inputmask.js"));
In Layout
@Scripts.Render("~/bundles/inputmask")

20
vendor/Inputmask/nuspecs/jquery.inputmask.nuspec vendored
View File

@@ -1,20 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
<metadata>
<id>jQuery.InputMask</id>
<version>0.0.0</version>
<title>Inputmask</title>
<authors>Robin Herbots</authors>
<owners>Robin Herbots</owners>
<licenseUrl>https://github.com/RobinHerbots/Inputmask/blob/4.x/LICENSE.txt</licenseUrl>
<projectUrl>https://github.com/RobinHerbots/Inputmask</projectUrl>
<requireLicenseAcceptance>true</requireLicenseAcceptance>
<description>Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.</description>
<summary>Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.</summary>
<tags>jQuery, plugins, input, form, inputmask, mask</tags>
</metadata>
<files>
<file src="..\dist\**\*" target="content\Scripts\inputmask" />
<file src="Readme.txt" target="Readme.txt" />
</files>
</package>

69
vendor/Inputmask/package.json vendored
View File

@@ -1,69 +0,0 @@
{
"name": "inputmask",
"version": "5.0.0-beta.190",
"description": "Inputmask is a javascript library which creates an input mask. Inputmask can run against vanilla javascript, jQuery and jqlite.",
"main": "index.js",
"files": [
"bundle.js",
"css/",
"dist/",
"lib/"
],
"scripts": {
"start": "webpack --progress --watch --config webpack.config.js",
"start_jquery": "webpack --progress --watch --config webpack.jqueryconfig.js",
"test": "grunt validate"
},
"repository": {
"type": "git",
"url": "https://github.com/RobinHerbots/Inputmask.git"
},
"keywords": [
"form",
"input",
"inputmask",
"jquery",
"jquery-plugin",
"mask",
"plugins"
],
"author": {
"name": "Robin Herbots",
"url": "https://github.com/RobinHerbots"
},
"license": "MIT",
"bugs": {
"url": "https://github.com/RobinHerbots/Inputmask/issues"
},
"homepage": "https://github.com/RobinHerbots/Inputmask",
"devDependencies": {
"@babel/core": "^7.3.4",
"@babel/helpers": "^7.3.1",
"babel-loader": "^8.0.5",
"@babel/preset-env": "^7.3.4",
"css-loader": "^2.1.1",
"grunt": "^1.0.3",
"grunt-available-tasks": "^0.6.3",
"grunt-bump": "^0.8.0",
"grunt-cli": "^1.3.2",
"grunt-contrib-clean": "^2.0.0",
"grunt-contrib-copy": "^1.0.0",
"grunt-eslint": "^21.0.0",
"grunt-nuget": "^0.3.1",
"grunt-release": "^0.14.0",
"grunt-webpack": "^3.1.3",
"jqlite": "^0.2.42",
"jquery": "^3.3.1",
"jsdom": "^13.2.0",
"load-grunt-tasks": "^4.0.0",
"loader-utils": "^1.2.3",
"postcss": "^7.0.14",
"postcss-cssnext": "^3.1.0",
"postcss-loader": "^3.0.0",
"qunit": "^2.9.2",
"style-loader": "^0.23.1",
"uglifyjs-webpack-plugin": "^2.1.2",
"webpack": "^4.29.6",
"webpack-cli": "^3.2.3"
}
}

71
vendor/Inputmask/qunit/index.js vendored
View File

@@ -1,71 +0,0 @@
import "../node_modules/qunit/qunit/qunit.css";
import "../css/inputmask.css";
import Inputmask from "../index";
import jQuery from "jquery";
if (Inputmask.dependencyLib === jQuery)
window.jQuery = Inputmask.dependencyLib;
import qunit from "qunit";
import "./prototypeExtensions.js";
import simulator from "./simulator.js";
// android testing
Inputmask.extendDefaults({
inputEventOnly: false
});
// window.Inputmask = Inputmask; //inject globally for the simulator to detect inputeventonly
import tests_alternations from "./tests_alternations";
import tests_attributes from "./tests_attributes";
import tests_base from "./tests_base";
import tests_date from "./tests_date";
import tests_dynamic from "./tests_dynamic";
import tests_escape from "./tests_escape";
import tests_formatvalidate from "./tests_formatvalidate";
import tests_initialvalue from "./tests_initialvalue";
import tests_inputeventonly from "./tests_inputeventonly";
import tests_ip from "./tests_ip";
import tests_jitmasking from "./tests_jitmasking";
import tests_jquery_inputmask from "./tests_jquery_inputmask";
import tests_keepStatic from "./tests_keepStatic";
import tests_multi from "./tests_multi";
import tests_numeric from "./tests_numeric";
import tests_numericinput from "./tests_numericinput";
import tests_option from "./tests_option";
import tests_optional from "./tests_optional";
import tests_paste from "./tests_paste";
import tests_regex from "./tests_regex";
import tests_setvalue from "./tests_setvalue";
//inject simulater code in the dependencies
simulator(Inputmask.dependencyLib, Inputmask);
simulator(jQuery, Inputmask);
//load tests
tests_alternations(qunit, Inputmask);
tests_attributes(qunit, Inputmask);
tests_base(qunit, Inputmask);
tests_date(qunit, Inputmask);
tests_dynamic(qunit, Inputmask);
tests_escape(qunit, Inputmask);
tests_formatvalidate(qunit, Inputmask);
tests_initialvalue(qunit, Inputmask);
tests_inputeventonly(qunit, Inputmask);
tests_ip(qunit, Inputmask);
tests_jitmasking(qunit, Inputmask);
tests_jquery_inputmask(qunit, jQuery, Inputmask);
tests_keepStatic(qunit, Inputmask);
tests_multi(qunit, Inputmask);
tests_numeric(qunit, Inputmask);
tests_numericinput(qunit, Inputmask);
tests_option(qunit, Inputmask);
tests_optional(qunit, Inputmask);
tests_paste(qunit, Inputmask);
tests_regex(qunit, Inputmask);
tests_setvalue(qunit, Inputmask);
qunit.load();
// qunit.start();

13
vendor/Inputmask/qunit/prototypeExtensions.js vendored
View File

@@ -1,13 +0,0 @@
/*
These are dummy prototype extensions to test that the inputmask code can deal with an extension
*/
Array.prototype.dummy = function(){
return false;
}
String.prototype.dummy = function(){
return false;
}

14
vendor/Inputmask/qunit/qunit.html vendored
View File

@@ -1,14 +0,0 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Inputmask - QUnit</title>
</head>
<body>
<div id="qunit"></div>
<div id="qunit-fixture"></div>²
<script src="../node_modules/jquery/dist/jquery.js"></script>
<script src="../node_modules/qunit/qunit/qunit.js"></script>
<script src="../qunit/qunit.js" charset="utf-8"></script>
</body>
</html>

222
vendor/Inputmask/qunit/simulator.js vendored
View File

@@ -1,222 +0,0 @@
export default function ($, Inputmask) {
$.caret = function (input, begin, end) {
input = input.nodeName ? input : input[0];
input.focus();
var range;
if (typeof begin === "number") {
end = (typeof end == "number") ? end : begin;
// if (!$(input).is(":visible")) {
// return;
// }
if (input.setSelectionRange) {
input.setSelectionRange(begin, end);
} else if (window.getSelection) {
range = document.createRange();
if (input.firstChild === undefined) {
var textNode = document.createTextNode("");
input.appendChild(textNode);
}
range.setStart(input.firstChild, begin < input.value.length ? begin : input.value.length);
range.setEnd(input.firstChild, end < input.value.length ? end : input.value.length);
range.collapse(true);
var sel = window.getSelection();
sel.removeAllRanges();
sel.addRange(range);
//input.focus();
} else if (input.createTextRange) {
range = input.createTextRange();
range.collapse(true);
range.moveEnd("character", end);
range.moveStart("character", begin);
range.select();
}
} else {
if ("selectionStart" in input && "selectionEnd" in input) {
begin = input.selectionStart;
end = input.selectionEnd;
} else if (window.getSelection) {
range = window.getSelection().getRangeAt(0);
if (range.commonAncestorContainer.parentNode === input || range.commonAncestorContainer === input) {
begin = range.startOffset;
end = range.endOffset;
}
} else if (document.selection && document.selection.createRange) {
range = document.selection.createRange();
begin = 0 - range.duplicate().moveStart("character", -100000);
end = begin + range.text.length;
}
/*eslint-disable consistent-return */
return {
"begin": begin,
"end": end
};
/*eslint-enable consistent-return */
}
};
$.fn = $.fn || $.prototype;
$.fn.SendKey = function (keyCode, modifier) {
var elem = this.nodeName ? this : this[0], origCode = keyCode;
elem.type = "text"; //force textinput to support caret fn
function trigger(elem, evnt) {
elem.focus();
if ($ === window.jQuery) {
$(elem).trigger(evnt);
} else {
if (document.createEvent) {
elem.dispatchEvent(evnt);
} else {
elem.fireEvent("on" + evnt.eventType, evnt);
}
}
}
var sendDummyKeydown = false;
if (Object.prototype.toString.call(keyCode) == '[object String]') {
keyCode = keyCode.charCodeAt(0);
sendDummyKeydown = true;
}
switch (keyCode) {
case Inputmask.keyCode.LEFT:
if (modifier == undefined) {
var pos = $.caret(this);
$.caret(this, pos.begin - 1);
break;
}
case Inputmask.keyCode.RIGHT:
if (modifier == undefined) {
var pos = $.caret(this);
$.caret(this, pos.begin + 1);
break;
}
default:
if ((window.Inputmask && window.Inputmask.prototype.defaults.inputEventOnly === true) ||
(elem.inputmask && elem.inputmask.opts.inputEventOnly === true)) {
var input = new $.Event("input"),
currentValue = (elem.inputmask && elem.inputmask.__valueGet) ? elem.inputmask.__valueGet.call(elem) : elem.value,
caretPos = $.caret(elem), caretOffset = 0;
// console.log("initial " + currentValue);
// console.log(caretPos);
var front = currentValue.substring(0, caretPos.begin),
back = currentValue.substring(caretPos.end),
newValue = currentValue;
switch (keyCode) {
case Inputmask.keyCode.BACKSPACE:
if (caretPos.begin === caretPos.end)
front = front.substr(0, front.length - 1)
newValue = front + back;
break;
case Inputmask.keyCode.DELETE:
if (origCode !== ".") {
if (caretPos.begin === caretPos.end)
back = back.slice(1);
newValue = front + back;
break;
}
default:
newValue = front + String.fromCharCode(keyCode) + back;
caretOffset = front.length > 0 ? 1 : 0;
break;
}
if (elem.inputmask && elem.inputmask.__valueSet)
elem.inputmask.__valueSet.call(elem, newValue);
else elem.value = newValue;
$.caret(elem, (newValue.length - back.length));
trigger(elem, input);
} else {
var keydown = new $.Event("keydown"),
keypress = new $.Event("keypress"),
keyup = new $.Event("keyup");
if (!sendDummyKeydown) {
keydown.keyCode = keyCode;
if (modifier == Inputmask.keyCode.CONTROL)
keydown.ctrlKey = true;
}
trigger(elem, keydown);
if (!keydown.defaultPrevented) {
keypress.keyCode = keyCode;
if (modifier == Inputmask.keyCode.CONTROL)
keypress.ctrlKey = true;
trigger(elem, keypress);
//if (!keypress.isDefaultPrevented()) {
keyup.keyCode = keyCode;
if (modifier == Inputmask.keyCode.CONTROL)
keyup.ctrlKey = true;
trigger(elem, keyup);
//}
}
}
}
}
if (!('append' in $.fn)) {
$.fn.append = function (child) {
var input = this.nodeName ? this : this[0];
input.insertAdjacentHTML('beforeend', child);
};
}
if (!('remove' in $.fn)) {
$.fn.remove = function () {
var input = this.nodeName ? this : this[0];
if (input !== undefined && input !== null) {
input.parentElement.removeChild(input);
input = undefined;
}
};
}
if (!('val' in $.fn)) {
$.fn.val = function (value) {
var input = this.nodeName ? this : this[0];
if (value !== undefined) {
if (input.inputmask) {
input.inputmask._valueSet(value, true);
$(input).trigger("setvalue");
} else input.value = value;
}
return input.value;
};
}
$.fn.Type = function (inputStr) {
var input = this.nodeName ? this : this[0],
$input = $(input);
$.each(inputStr.split(''), function (ndx, lmnt) {
$input.SendKey(lmnt);
});
}
$.fn.paste = function (inputStr) {
var input = this.nodeName ? this : this[0],
$input = $(input);
if (window.clipboardData) {
window.clipboardData.setData('Text', inputStr);
} else {
$.data($input, "clipboard", inputStr);
window.clipboardData = {
getData: function () {
window.clipboardData = undefined;
return $.data($input, "clipboard");
}
}
}
$input.trigger('paste');
}
$.fn.input = function (inputStr, caretBegin, caretEnd) {
var input = this.nodeName ? this : this[0];
input.inputmask.__valueSet.call(input, inputStr);
if (caretBegin !== undefined)
$.caret(input, caretBegin, caretEnd);
$(input).trigger("input");
}
};

414
vendor/Inputmask/qunit/tests_alternations.js vendored
View File

@@ -1,414 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Alternations");
qunit.test("\"9{1,2}C|S A{1,3} 9{4}\" - ankitajain32", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9{1,2}C|S A{1,3} 9{4}").mask(testmask);
$("#testmask").Type("12Cabc1234");
assert.equal(testmask.inputmask._valueGet(), "12C ABC 1234", "Result " + testmask.inputmask._valueGet());
});
qunit.test("\"9{1,2}C|S A{1,3} 9{4}\" replace C with S - ankitajain32", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9{1,2}C|S A{1,3} 9{4}").mask(testmask);
$("#testmask").Type("12Cabc1234");
$.caret(testmask, 2, 3);
$("#testmask").Type("S");
assert.equal(testmask.inputmask._valueGet(), "12S ABC 1234", "Result " + testmask.inputmask._valueGet());
});
qunit.test("nested alternations 1", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("0<2)##-##-##>|<3<4)#-##-##>|<5)#-##-##>|<6)#-##-##>>", {
groupmarker: ["<", ">"]
}).mask(testmask);
$("#testmask").Type("02121212");
assert.equal(testmask.inputmask._valueGet(), "02)12-12-12", "Result " + testmask.inputmask._valueGet());
});
qunit.test("nested alternations 2", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("0<2)##-##-##>|<3<4)#-##-##>|<5)#-##-##>|<6)#-##-##>>", {
groupmarker: ["<", ">"]
}).mask(testmask);
$("#testmask").Type("03411212");
assert.equal(testmask.inputmask._valueGet(), "034)1-12-12", "Result " + testmask.inputmask._valueGet());
});
qunit.test("nested alternations 3", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("0<2)##-##-##>|<3<4)#-##-##>|<5)#-##-##>|<6)#-##-##>>", {
groupmarker: ["<", ">"]
}).mask(testmask);
$("#testmask").Type("03511212");
assert.equal(testmask.inputmask._valueGet(), "035)1-12-12", "Result " + testmask.inputmask._valueGet());
});
qunit.test("nested alternations 4", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("0<2)##-##-##>|<3<4)#-##-##>|<5)#-##-##>|<6)#-##-##>>", {
groupmarker: ["<", ">"]
}).mask(testmask);
$("#testmask").Type("03611212");
assert.equal(testmask.inputmask._valueGet(), "036)1-12-12", "Result " + testmask.inputmask._valueGet());
});
qunit.test("alternations W|XY|Z", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("W|XY|Z").mask(testmask);
$("#testmask").Type("WZ");
assert.equal(testmask.inputmask._valueGet(), "WZ", "Result " + testmask.inputmask._valueGet());
});
qunit.test("alternations (W)|(X)(Y)|(Z)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(W)|(X)(Y)|(Z)").mask(testmask);
$("#testmask").Type("WZ");
assert.equal(testmask.inputmask._valueGet(), "WZ", "Result " + testmask.inputmask._valueGet());
});
qunit.test("alternations (9{1,3}|SE|NE|SW|NW)-9{1,3} - yesman85", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9{1,3}|SE|NE|SW|NW)-9{1,3}").mask(testmask);
$("#testmask").Type("(NE123");
assert.equal(testmask.inputmask._valueGet(), "NE-123", "Result " + testmask.inputmask._valueGet());
});
qunit.test("((S))", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("((S))").mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(testmask.inputmask._valueGet(), "((S))", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("((S)", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("((S)").mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(testmask.inputmask._valueGet(), "((S)", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("+371-99-999-999 - artemkaint", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask([
"+371-99-999-999",
"+370(999)99-999",
"+375(99)999-99-99",
"+374-99-999-999",
"+380(99)999-99-99",
"+358(999)999-99-99",
"+373-9999-9999",
"+381-99-999-9999"
]).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("112123123");
assert.equal(testmask.inputmask._valueGet(), "+371-12-123-123", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("+371-99-999-999 - artemkaint", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask([
"+371-99-999-999",
"+370(999)99-999",
"+375(99)999-99-99",
"+374-99-999-999",
"+380(99)999-99-99",
"+358(999)999-99-99",
"+373-9999-9999",
"+381-99-999-9999"
]).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("412123123");
assert.equal(testmask.inputmask._valueGet(), "+374-12-123-123", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("(9)|(a9) - type 1 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9)|(a9)").mask(testmask);
testmask.focus();
$("#testmask").Type("12");
assert.equal(testmask.inputmask._valueGet(), "1", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9)|(a9) - type a1 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9)|(a9)").mask(testmask);
testmask.focus();
$("#testmask").Type("a1");
assert.equal(testmask.inputmask._valueGet(), "a1", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(999)|(0aa) - type 0ab - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999)|(0aa)").mask(testmask);
testmask.focus();
$("#testmask").Type("0ab");
assert.equal(testmask.inputmask._valueGet(), "0ab", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(999)|(0aa) - type 1ab - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999)|(0aa)").mask(testmask);
testmask.focus();
$("#testmask").Type("1ab");
assert.equal(testmask.inputmask._valueGet(), "1__", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9)|(09)|(19)|(2f) - type 41 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9)|(09)|(19)|(2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("41");
assert.equal(testmask.inputmask._valueGet(), "4", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9)|(09)|(19)|(2f) - type 01 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9)|(09)|(19)|(2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("01");
assert.equal(testmask.inputmask._valueGet(), "01", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9)|(09)|(19)|(2f) - type 11 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9)|(09)|(19)|(2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("11");
assert.equal(testmask.inputmask._valueGet(), "11", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9)|(09)|(19)|(2f) - type 23 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9)|(09)|(19)|(2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.inputmask._valueGet(), "23", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9|09|19|2f) - type 24 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9|09|19|2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("24");
assert.equal(testmask.inputmask._valueGet(), "2", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(1|2|3)/(4|5)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(1|2|3)/(4|5)").mask(testmask);
testmask.focus();
$("#testmask").Type("34");
assert.equal(testmask.inputmask._valueGet(), "3/4", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(99)|(*a)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99)|(*a)").mask(testmask);
testmask.focus();
$("#testmask").Type("12");
assert.equal(testmask.inputmask._valueGet(), "12", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(99)|(*a)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99)|(*a)").mask(testmask);
testmask.focus();
$("#testmask").Type("1a");
assert.equal(testmask.inputmask._valueGet(), "1a", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(99)|(*a)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99)|(*a)").mask(testmask);
testmask.focus();
$("#testmask").Type("ab");
assert.equal(testmask.inputmask._valueGet(), "ab", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(99)|(*a)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99)|(*a)").mask(testmask);
testmask.focus();
$("#testmask").Type("a2");
assert.equal(testmask.inputmask._valueGet(), "a_", "Result " + testmask.inputmask._valueGet());
});
qunit.test("regex: \"([0-9]{2})|([a-z0-9][a-z])\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({regex: "([0-9]{2})|([a-z0-9][a-z])"}).mask(testmask);
testmask.focus();
$("#testmask").Type("a2");
assert.equal(testmask.inputmask._valueGet(), "a_", "Result " + testmask.inputmask._valueGet());
});
qunit.test("9|(9a)", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9|(9a)").mask(testmask);
testmask.focus();
$("#testmask").Type("1");
assert.equal(testmask.inputmask._valueGet(), "1", "Result " + testmask.inputmask._valueGet());
});
qunit.test("([0]9)|(19)|(2f) - type 26 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("([0]9)|(19)|(2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("26");
assert.equal(testmask.inputmask._valueGet(), "2", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(0{0,1}9)|(19)|(2f) - type 26 - ivaninDarpatov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(0{0,1}9)|(19)|(2f)", {
definitions: {
"f": {validator: "[0-3]"}
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("26");
assert.equal(testmask.inputmask._valueGet(), "2", "Result " + testmask.inputmask._valueGet());
});
};

24
vendor/Inputmask/qunit/tests_attributes.js vendored
View File

@@ -1,24 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Attribute options");
qunit.test("data-inputmask=\"'alias':'integer', 'allowMinus': false, 'allowPlus': false\" - StennikovDmitriy", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" data-inputmask="\'alias\':\'integer\', \'allowMinus\': false, \'allowPlus\': false" />');
var testmask = document.getElementById("testmask");
Inputmask().mask(testmask);
$("#testmask").Type("1234,56");
assert.equal(testmask.value, "123456", "Result " + testmask.value);
});
qunit.test("data-inputmask=\"'mask':'[9-]AAA-999'\" - airomero", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" data-inputmask="\'mask\':\'[9-]AAA-999\'" />');
var testmask = document.getElementById("testmask");
Inputmask().mask(testmask);
$("#testmask").Type("abc123");
assert.equal(testmask.value, "ABC-123", "Result " + testmask.value);
});
};

543
vendor/Inputmask/qunit/tests_base.js vendored
View File

@@ -1,543 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Simple masking");
qunit.test("inputmask(\"99-99-99\", { clearMaskOnLostFocus: false}", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99-99-99",
clearMaskOnLostFocus: false
}).mask(testmask);
assert.equal(testmask.inputmask._valueGet(), "__-__-__", "Result " + testmask.inputmask._valueGet());
});
qunit.test("inputmask(\"99-99-99\", { clearMaskOnLostFocus: true}", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99-99-99",
clearMaskOnLostFocus: false
}).mask(testmask);
testmask.blur();
setTimeout(function () {
assert.equal(testmask.value, "", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"999.999.999\")", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123");
assert.equal(testmask.value, "123.___.___", "Result " + testmask.value);
});
qunit.test("inputmask(\"999.999.999\") + backspace", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "12_.___.___", "Result " + testmask.value);
});
qunit.test("inputmask(\"999.999.999\", { oncomplete: ... })", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999", {
oncomplete: function () {
assert.equal(testmask.value, "123.456.789", "Result " + testmask.value);
testmask.inputmask.remove();
done();
}
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456789");
});
// qunit.test("inputmask(\"9-AAA.999\") - change event", function (assert) {
// var done = assert.async(),
// $fixture = $("#qunit-fixture");
// $fixture.append('<input type="text" id="testmask" />');
// var testmask = document.getElementById("testmask");
//
// $("#testmask").on("change", function () {
// assert.ok(true, "Change triggered");
// done();
// });
//
// Inputmask("9-AAA.999").mask(testmask);
//
// testmask.focus();
// setTimeout(function () {
// $("#testmask").Type("1abc12");
// testmask.blur();
// }, 0);
// });
qunit.test("inputmask(\"9-AAA.999\", { onincomplete: ... })", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9-AAA.999", {
onincomplete: function () {
assert.equal(testmask.value, "1-ABC.12_", "Result " + testmask.value);
testmask.inputmask.remove();
done();
}
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("1abc12");
testmask.blur();
}, 0);
});
qunit.test("inputmask(\"999.999.999\") - delete 2nd with backspace, continue the mask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123");
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").Type("4");
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").Type("56");
assert.equal(testmask.value, "143.56_.___", "Result " + testmask.value);
});
qunit.test("inputmask(\"999.999.999\") - delete 2nd with delete, continue the mask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123");
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").Type("4");
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").Type("56");
assert.equal(testmask.value, "143.56_.___", "Result " + testmask.value);
});
qunit.test("inputmask(\"999.999.999\") - delete selection start with nomask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123456789");
$.caret(testmask, 3, 7);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(testmask.value, "123.789.___", "Result " + testmask.value);
});
qunit.test("inputmask(\"999.999.999\") - backspace selection start with nomask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123456789");
$.caret(testmask, 3, 7);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "123.789.___", "Result " + testmask.value);
});
qunit.test("inputmask(\"999.999.999\") - overtype selection start with nomask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
$("#testmask").Type("123456789");
$.caret(testmask, 3, 7);
$("#testmask").Type("1");
assert.equal(testmask.value, "123.178.9__", "Result " + testmask.value);
});
qunit.test("inputmask(\"*****\")", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("*****").mask(testmask);
testmask.focus();
$("#testmask").Type("abe");
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").Type("cd");
assert.equal(testmask.value, "abcde", "Result " + testmask.value);
});
qunit.test("inputmask(\"(999)999-9999\") - ruslanfedoseenko mask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999)999-9999").mask(testmask);
testmask.focus();
testmask.value = "9999999999";
$.caret(testmask, 4);
$("#testmask").Type("7");
assert.equal(testmask.value, "(999)999-9999", "Result " + testmask.value);
});
qunit.test("inputmask(\"(999)999-9999\") - insert false - ruslanfedoseenko mask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999)999-9999", {
insertMode: false
}).mask(testmask);
testmask.focus();
testmask.value = "9999999999";
$.caret(testmask, 4);
$("#testmask").Type("7");
assert.equal(testmask.value, "(999)999-9999", "Result " + testmask.value);
});
qunit.test("inputmask(\"\") - empty mask - andywolk", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("").mask(testmask);
testmask.focus();
$("#testmask").val("123");
assert.equal(testmask.value, "123", "Result " + testmask.value);
});
qunit.test("Delete selection with non-masks", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999)999-9999").mask(testmask);
testmask.focus();
$("#testmask").Type("9999999999");
$.caret(testmask, 8, 11);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(testmask.value, "(999)999-99__", "Result " + testmask.value);
});
qunit.test("Selection and backspace also deletes previous - kenaku", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999 99 99 999").mask(testmask);
testmask.focus();
$("#testmask").Type("1234567890");
$.caret(testmask, 2, 3);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "124 56 78 90_", "Result " + testmask.value);
});
qunit.module("Non-greedy masks");
qunit.test("inputmask(\"*\", { greedy: false, repeat: \"*\" }) - replace cd with 1", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("*", {
greedy: false,
repeat: "*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcdef");
$.caret(testmask, 2, 4);
$("#testmask").SendKey("1");
assert.equal(testmask.value, "ab1ef", "Result " + testmask.value);
});
qunit.test("inputmask(\"*\", { greedy: false, repeat: \"*\" }) - type abcdef", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("*", {
greedy: false,
repeat: "*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcdef");
assert.equal(testmask.value, "abcdef", "Result " + testmask.value);
});
qunit.test("inputmask(\"A.\", { repeat: \"*\" }) - type abc - joostburg", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("A.", {
repeat: "*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abc");
assert.equal(testmask.value, "A.B.C.", "Result " + testmask.value);
});
qunit.test("{ mask: \"A\", placeholder: \"\", repeat: 16 }) - type testtest - glosswordteam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "A",
placeholder: "",
repeat: 16
}).mask(testmask);
testmask.focus();
$("#testmask").Type("testtest");
assert.equal(testmask.value, "TESTTEST", "Result " + testmask.value);
});
qunit.test("{ mask: \"A\", repeat: 16, greedy: false }) - type testtest - glosswordteam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "A",
repeat: 16,
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("testtest");
assert.equal(testmask.value, "TESTTEST", "Result " + testmask.value);
});
qunit.module("greedy masks");
qunit.test("inputmask(\"*\", { greedy: true, repeat: 10, clearMaskOnLostFocus: false })", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("*", {
greedy: true,
repeat: 10,
clearMaskOnLostFocus: false
}).mask(testmask);
testmask.focus();
assert.equal($("#testmask")[0].inputmask._valueGet(), "__________", "Result " + $("#testmask")[0].inputmask._valueGet());
});
qunit.test("inputmask(\"*\", { greedy: true, repeat: 10 }) - type 12345678901234567890", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("*", {
greedy: true,
repeat: 10
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345678901234567890");
assert.equal(testmask.value, "1234567890", "Result " + testmask.value);
});
qunit.test("inputmask(\"9,99\", { greedy: true, repeat: 5 }) - type 12345678901234567890", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9,99", {
greedy: true,
repeat: 5
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345678901234567890");
assert.equal(testmask.value, "1,234,567,890,123,45", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"9\", repeat: 10, placeholder: \"\", numericInput: true }) - greedy true with empty placeholder - type 12345", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"mask": "9",
repeat: 10,
placeholder: "",
numericInput: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345");
assert.equal(testmask.value, "12345", "Result " + testmask.value);
});
qunit.test("creditcard switch - pchelailya", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9999 9999 9999 9999").mask(testmask);
$("#testmask").on("keyup input", function (event) {
var value = this.inputmask.unmaskedvalue();
if (value != null && value.length === 2 && value === "37") {
Inputmask("9999 999999 99999").mask(this);
}
});
testmask.focus();
$("#testmask").Type("37");
setTimeout(function () {
$("#testmask").Type("12");
assert.equal(testmask.value, "3712 ______ _____", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("maskscache - same mask diff definitions - StonesEditeurs", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "Z{1,*}",
definitions: {
"Z": {
validator: function (chrs, buffer, pos, strict, opts) {
return {
pos: pos,
c: "A"
};
},
}
}
}).mask(testmask);
Inputmask({
mask: "Z{1,*}", // <= Same mask
definitions: {
"Z": {
validator: function (chrs, buffer, pos, strict, opts) {
return {
pos: pos,
c: "B"
}; // <= another definition
},
}
}
}).mask(testmask);
$("#testmask").Type("abcdef");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "BBBBBB", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("autoUnmask not work in newest release #1109 - danilG", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "+7 999 999-99-99",
autoUnmask: true
}).mask(testmask);
$(testmask).val("9226845186");
//Let's get value exact immediate - this crack's
$(testmask).val();
$(testmask).trigger("mouseenter");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "+7 922 684-51-86", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("Title Case - Especially", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("p{1,10}", {
definitions: {
"p": {
validator: "[A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5 ]",
cardinality: 1,
casing: "title" //auto uppercasing
}
},
}).mask(testmask);
$(testmask).val("title case");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "Title Case", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("Bug when typing after a fixed character #1299 - gayanj", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("AaaBAaaVaa").mask(testmask);
testmask.focus();
setTimeout(function () {
$.caret(testmask, 4);
$("#testmask").Type("a");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "___BA__V__", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
};

610
vendor/Inputmask/qunit/tests_date.js vendored
View File

@@ -1,610 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
function pad(val, len) {
val = String(val);
len = len || 2;
while (val.length < len) val = "0" + val;
return val;
}
qunit.module("Date.Extensions - dd/mm/yyyy");
qunit.test("valid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
assert.equal(testmask.value, "23/03/1973", "Result " + testmask.value);
});
qunit.test("invalid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcdefghijklmnop");
assert.equal(testmask.value, "", "Result " + testmask.value);
});
qunit.test("overtype valid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$.caret(testmask, 0, "23/03/1973".length);
$("#testmask").Type("04102017");
assert.equal(testmask.value, "04/10/2017", "Result " + testmask.value);
});
qunit.test("overtype invalid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$.caret(testmask, 0, "23/03/1973".length);
$("#testmask").Type("abcdefghijklmnop");
assert.equal(testmask.value, "23/03/1973", "Result " + testmask.value);
});
qunit.test("insert current date", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").SendKey(Inputmask.keyCode.RIGHT, Inputmask.keyCode.CONTROL);
var today = new Date();
today = pad(today.getDate(), 2) + "/" + pad(parseInt(today.getMonth()) + 1, 2) + "/" + today.getFullYear();
assert.equal(testmask.value, today, "Result " + testmask.value);
});
qunit.test("backspace year", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "23/03/yyyy", "Result " + testmask.value);
});
qunit.test("delete year", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$.caret(testmask, "23/03/".length);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(testmask.value, "23/03/yyyy", "Result " + testmask.value);
});
qunit.test("set date 592017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").val("592017");
assert.equal(testmask.value, "05/09/2017", "Result " + testmask.value);
});
qunit.test("set date 01/01/1800 min date 01/01/1900", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
min: "01/01/1900",
max: "31/12/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011800");
assert.equal(testmask.value, "01/01/1yyy", "Result " + testmask.value);
});
qunit.test("set date 01/01/2018 max date 31/12/2017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
min: "01/01/1900",
max: "31/12/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01012018");
assert.equal(testmask.value, "01/01/201y", "Result " + testmask.value);
});
qunit.test("set date 01/01/1900 min date 01/01/1900", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
min: "01/01/1900",
max: "31/12/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011900");
assert.equal(testmask.value, "01/01/1900", "Result " + testmask.value);
});
qunit.test("set date 31/12/2017 max date 31/12/2017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
min: "01/01/1900",
max: "31/12/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("31122017");
assert.equal(testmask.value, "31/12/2017", "Result " + testmask.value);
});
qunit.test("min 14/02/1938 max 14/02/2038 enter 01011939", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd/mm/yyyy",
min: "14/02/1938",
max: "14/02/2038"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011939");
assert.equal(testmask.value, "01/01/1939", "Result " + testmask.value);
});
qunit.module("Date.Extensions - mm/dd/yyyy");
qunit.test("valid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("3231973");
assert.equal(testmask.value, "03/23/1973", "Result " + testmask.value);
});
qunit.test("invalid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcdefghijklmnop");
assert.equal(testmask.value, "", "Result " + testmask.value);
});
qunit.test("overtype valid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("3231973");
$.caret(testmask, 0, "03/23/1973".length);
$("#testmask").Type("10042017");
assert.equal(testmask.value, "10/04/2017", "Result " + testmask.value);
});
qunit.test("overtype invalid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("3231973");
$.caret(testmask, 0, "03/23/1973".length);
$("#testmask").Type("abcdefghijklmnop");
assert.equal(testmask.value, "03/23/1973", "Result " + testmask.value);
});
qunit.test("insert current date", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").SendKey(Inputmask.keyCode.RIGHT, Inputmask.keyCode.CONTROL);
var today = new Date();
today = pad(parseInt(today.getMonth()) + 1, 2) + "/" + pad(today.getDate(), 2) + "/" + today.getFullYear();
assert.equal(testmask.value, today, "Result " + testmask.value);
});
qunit.test("backspace year", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("3231973");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "03/23/yyyy", "Result " + testmask.value);
});
qunit.test("delete year", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("3231973");
$.caret(testmask, "03/23/".length);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(testmask.value, "03/23/yyyy", "Result " + testmask.value);
});
qunit.test("set date 952017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").val("952017");
assert.equal(testmask.value, "09/05/2017", "Result " + testmask.value);
});
qunit.test("set date 01/01/1800 min date 01/01/1900", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy",
min: "01/01/1900",
max: "12/31/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011800");
assert.equal(testmask.value, "01/01/1yyy", "Result " + testmask.value);
});
qunit.test("set date 01/01/2018 max date 12/31/2017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy",
min: "01/01/1900",
max: "12/31/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01012018");
assert.equal(testmask.value, "01/01/201y", "Result " + testmask.value);
});
qunit.test("set date 01/01/1900 min date 01/01/1900", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy",
min: "01/01/1900",
max: "12/31/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011900");
assert.equal(testmask.value, "01/01/1900", "Result " + testmask.value);
});
qunit.test("set date 12/31/2017 max date 12/31/2017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy",
min: "01/01/1900",
max: "12/31/2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("12312017");
assert.equal(testmask.value, "12/31/2017", "Result " + testmask.value);
});
qunit.test("min 02/14/1938 max 02/14/2038 enter 01011939", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/dd/yyyy",
min: "02/14/1938",
max: "02/14/2038"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011939");
assert.equal(testmask.value, "01/01/1939", "Result " + testmask.value);
});
qunit.module("Date.Extensions - dd.mm.yyyy");
qunit.test("valid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
assert.equal(testmask.value, "23.03.1973", "Result " + testmask.value);
});
qunit.test("invalid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcdefghijklmnop");
assert.equal(testmask.value, "", "Result " + testmask.value);
});
qunit.test("overtype valid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$.caret(testmask, 0, "23.03.1973".length);
$("#testmask").Type("04102017");
assert.equal(testmask.value, "04.10.2017", "Result " + testmask.value);
});
qunit.test("overtype invalid entry", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$.caret(testmask, 0, "23.03.1973".length);
$("#testmask").Type("abcdefghijklmnop");
assert.equal(testmask.value, "23.03.1973", "Result " + testmask.value);
});
qunit.test("insert current date", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").SendKey(Inputmask.keyCode.RIGHT, Inputmask.keyCode.CONTROL);
var today = new Date();
today = pad(today.getDate(), 2) + "." + pad(parseInt(today.getMonth()) + 1, 2) + "." + today.getFullYear();
assert.equal(testmask.value, today, "Result " + testmask.value);
});
qunit.test("backspace year", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "23.03.yyyy", "Result " + testmask.value);
});
qunit.test("delete year", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("2331973");
$.caret(testmask, "23.03.".length);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(testmask.value, "23.03.yyyy", "Result " + testmask.value);
});
qunit.test("set date 592017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy"
}).mask(testmask);
testmask.focus();
$("#testmask").val("592017");
assert.equal(testmask.value, "05.09.2017", "Result " + testmask.value);
});
qunit.test("set date 01.01.1800 min date 01.01.1900", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy",
min: "01.01.1900",
max: "31.12.2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011800");
assert.equal(testmask.value, "01.01.1yyy", "Result " + testmask.value);
});
qunit.test("set date 01.01.2018 max date 31.12.2017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy",
min: "01.01.1900",
max: "31.12.2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01012018");
assert.equal(testmask.value, "01.01.201y", "Result " + testmask.value);
});
qunit.test("set date 01/01/1900 min date 01/01/1900", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy",
min: "01.01.1900",
max: "31.12.2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011900");
assert.equal(testmask.value, "01.01.1900", "Result " + testmask.value);
});
qunit.test("set date 31.12.2017 max date 31.12.2017", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy",
min: "01.01.1900",
max: "31.12.2017"
}).mask(testmask);
testmask.focus();
$("#testmask").val("31122017");
assert.equal(testmask.value, "31.12.2017", "Result " + testmask.value);
});
qunit.test("min 14.02.1938 max 14.02.2038 enter 01011939", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "dd.mm.yyyy",
min: "14.02.1938",
max: "14.02.2038"
}).mask(testmask);
testmask.focus();
$("#testmask").val("01011939");
assert.equal(testmask.value, "01.01.1939", "Result " + testmask.value);
});
qunit.module("Date.Extensions - misc");
qunit.test("HH:MM minmax 10:00 - 11:10 enter 1059", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "HH:MM",
min: "10:00",
max: "11:10"
}).mask(testmask);
testmask.focus();
$("#testmask").val("1059");
assert.equal(testmask.value, "10:59", "Result " + testmask.value);
});
qunit.test("HH:MM minmax 10:00 - 11:10 enter 1230", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "HH:MM",
min: "10:00",
max: "11:10"
}).mask(testmask);
testmask.focus();
$("#testmask").val("1230");
assert.equal(testmask.value, "11:MM", "Result " + testmask.value);
});
};

448
vendor/Inputmask/qunit/tests_dynamic.js vendored
View File

@@ -1,448 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Dynamic Masks");
qunit.test("inputmask(\"9-a{3}9{3}\" - simple dynamic mask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9-a{3}9{3}").mask(testmask);
testmask.focus();
$("#testmask").Type("1abc123");
assert.equal(testmask.value, "1-abc123", "Result " + testmask.value);
});
qunit.test("inputmask(\"9-a{1,3}9{1,3}\" - simple dynamic mask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9-a{1,3}9{1,3}").mask(testmask);
testmask.focus();
$("#testmask").Type("1a1");
assert.equal(testmask.value, "1-a1", "Result " + testmask.value);
});
qunit.test("inputmask(\"9-a{1,3}9{1,3}\" - simple dynamic mask - greedy false", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9-a{1,3}9{1,3}", {
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("1a1");
assert.equal(testmask.value, "1-a1", "Result " + testmask.value);
});
qunit.test("inputmask(\"9-a{1,3}/9{2,3}\" - simple dynamic mask - greedy true", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9-a{1,3}/9{2,3}", {
greedy: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("1a/123");
assert.equal(testmask.value, "1-a/123", "Result " + testmask.value);
});
qunit.test("email mask greedy false", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email", {
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("some.body@mail.com");
testmask.blur();
assert.equal(testmask.value, "some.body@mail.com", "Result " + testmask.value);
});
qunit.test("email mask greedy true", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email", {
greedy: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("some.body@mail.com");
testmask.blur();
setTimeout(function () {
assert.equal(testmask.value, "some.body@mail.com", "Result " + testmask.value);
done();
}, 0);
}, 0);
});
qunit.test("email mask - partial input", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("some.");
testmask.blur();
assert.equal(testmask.value, "some.@_._", "Result " + testmask.value);
});
qunit.test("email mask - partial input 2", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("some@mail.com");
$.caret(testmask, 4);
$("#testmask").Type(".body");
assert.equal(testmask.value, "some.body@mail.com", "Result " + testmask.value);
});
qunit.test("email mask - babu@us.lufthansa.com - babupca", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("babu@us.lufthansa.com");
assert.equal(testmask.value, "babu@us.lufthansa.com", "Result " + testmask.value);
});
qunit.test("email mask - email@subdomain.domain.com - babupca", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("email@subdomain.domain.com");
assert.equal(testmask.value, "email@subdomain.domain.com", "Result " + testmask.value);
});
qunit.test("email mask - paste test.test@test.com - Kurumas", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").paste("test.test@test.com");
setTimeout(function () {
assert.equal(testmask.value, "test.test@test.com", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("quantifier mask greedy false - FairSite2C", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9{0,4}", {
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123");
assert.equal(testmask.value, "123", "Result " + testmask.value);
});
qunit.test("quantifier mask greedy true - FairSite2C", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9{0,4}", {
greedy: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123");
assert.equal(testmask.value, "123", "Result " + testmask.value);
});
qunit.test("email mask - clearIncomplete - hiddenman", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email", {
clearIncomplete: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("akornilov");
testmask.blur();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
}, 0);
});
qunit.test("email mask - clearIncomplete - hiddenman", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email", {
clearIncomplete: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("akornilov@");
testmask.blur();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
}, 0);
});
qunit.test("email mask - clearIncomplete - hiddenman", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email", {
clearIncomplete: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("akornilov@gmail.com");
testmask.blur();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "akornilov@gmail.com", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("mask: '\\\\a{*}', repeat: 5 - voidmain02", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "\\\\a{*}",
repeat: 5
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcd abcd abcd abcd abcd");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "\\abcd\\abcd\\abcd\\abcd\\abcd", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("[a{1,3}-]9999 - type abc1234 => delete c - ivodopyanov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("[a{1,3}-]9999").mask(testmask);
$("#testmask").Type("abc1234");
$.caret(testmask, 2);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "ab-1234", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("email mask - mouseclick to domain part - hiddenman", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("akornilov");
//fake click in position
$.caret(testmask, 10);
$("#testmask").trigger("click");
$("#testmask").Type("gmail.com");
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "akornilov@gmail.com", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("I{1,3}-ZZ - rgafaric", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" value=\"VAA\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"mask": "I{1,3}-ZZ",
definitions: {
"Z": {
"validator": "[A-Za-z]",
cardinality: 1
},
"I": {
"validator": "[ivxlcdmIVXLCDM]",
cardinality: 1
}
}
}).mask(testmask);
testmask.blur();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "V-AA", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("email mask - some.body@mail.com - delete before @", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("some.body@mail.com");
$.caret(testmask, 9);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
assert.equal(testmask.value, "some.body@ail.com", "Result " + testmask.value);
});
qunit.test("email mask -123@mail.com - 123 => info", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("email").mask(testmask);
testmask.focus();
$("#testmask").Type("123@mail.com");
$.caret(testmask, 0, 3);
$("#testmask").Type("info");
assert.equal(testmask.value, "info@mail.com", "Result " + testmask.value);
});
qunit.test("(aa)|(a.a.)|(aaa)|(aa.a.)|(a.aa.) - incomplete - danielpiterak", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(aa)|(a.a.)|(aaa)|(aa.a.)|(a.aa.)", {
clearMaskOnLostFocus: true,
showMaskOnHover: false,
placeholder: " ",
casing: "upper"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("p.p");
testmask.blur();
assert.equal(testmask.value, "P.P.", "Result " + testmask.value);
});
qunit.test("(aa)|(a.a.)|(aaa)|(aa.a.)|(a.aa.) - complete - danielpiterak", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(aa)|(a.a.)|(aaa)|(aa.a.)|(a.aa.)", {
clearMaskOnLostFocus: true,
showMaskOnHover: false,
placeholder: " ",
casing: "upper"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("p.p.");
testmask.blur();
assert.equal(testmask.value, "P.P.", "Result " + testmask.value);
});
qunit.test("(99){+|1}a - dynamic jit offset", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99){+|1}a").mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
$("#testmask").Type("1a");
assert.equal(testmask.value, "1a", "Result " + testmask.value);
});
qunit.test("(.999){+|1},00 - Loop trigger in revalidateMask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(.999){+|1},00", {
radixPoint: ",",
numericInput: true,
placeholder: "0",
definitions: {
"0": {
validator: "[0-9\uFF11-\uFF19]"
}
}
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
$("#testmask").Type("123333333333333333333333");
assert.equal(testmask.value, "0,12", "Result " + testmask.value);
});
qunit.test("a9{+} - Loop trigger in revalidateMask", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("a9{+}").mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
$("#testmask").Type("a");
$.caret(testmask, 0);
$("#testmask").Type("a");
assert.equal(testmask.value, "a_", "Result " + testmask.value);
});
qunit.test("Loop trigger in gettests", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"mask": "(99) 99999-9999[ ]",
"repeat": "*"
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
$("#testmask").Type("12123451234");
assert.equal(testmask.value, "(12) 12345-1234", "Result " + testmask.value);
});
};

105
vendor/Inputmask/qunit/tests_escape.js vendored
View File

@@ -1,105 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Escape character");
qunit.test("inputmask(\"9\\|9\")", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
var input = $("#testmask");
Inputmask("9\\|9").mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.value, "2|3", "Result " + testmask.value);
});
qunit.test("inputmask(\"9\\[9\\]\")", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
var input = $("#testmask");
Inputmask("9\\[9\\]").mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.value, "2[3]", "Result " + testmask.value);
});
qunit.test("inputmask(\"9\\\\9\")", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
var input = $("#testmask");
Inputmask("9\\\\9").mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.value, "2\\3", "Result " + testmask.value);
});
qunit.test("inputmask(\"9\\{9\\}\")", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("9\\{9\\}").mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.value, "2{3}", "Result " + testmask.value);
});
qunit.test("inputmask(\"9\\(9\\)\")", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("9\\(9\\)").mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.value, "2(3)", "Result " + testmask.value);
});
qunit.test("inputmask(\"9\\?9\")", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("9\\?9").mask(testmask);
testmask.focus();
$("#testmask").Type("23");
assert.equal(testmask.value, "2?3", "Result " + testmask.value);
});
qunit.test("inputmask(\"\\9999\") value not mask", function(assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" value="999" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("\\9999", {
autoUnmask: true
}).mask(testmask);
testmask.focus();
assert.equal(testmask.inputmask._valueGet(), "9999", "Result " + testmask.inputmask._valueGet());
});
};

228
vendor/Inputmask/qunit/tests_formatvalidate.js vendored
View File

@@ -1,228 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Value formatting");
qunit.test("Inputmask.format(\"2331973\", { alias: \"datetime\"})", function (assert) {
var formattedValue = Inputmask.format("2331973", {
alias: "datetime",
inputFormat: "dd/mm/yyyy"
});
assert.equal(formattedValue, "23/03/1973", "Result " + formattedValue);
});
qunit.test("Inputmask.format(\"016501030020001DE1015170\", { mask: \"99 999 999 999 9999 \\D\\E*** 9999\"})", function (assert) {
var formattedValue = Inputmask.format("016501030020001DE1015170", {
mask: "99 999 999 999 9999 \\D\\E*** 9999"
});
assert.equal(formattedValue, "01 650 103 002 0001 DE101 5170", "Result " + formattedValue);
});
qunit.test("Inputmask.format(\"12\", { mask: \"$ 999999\", numericInput: true, placeholder: \"0\" }); - gigermocas", function (assert) {
var formattedValue = Inputmask.format("12", {
mask: "$ 999999",
numericInput: true,
placeholder: "0"
});
assert.equal(formattedValue, "$ 000012", "Result " + formattedValue);
});
qunit.test("Inputmask.format(\"1111111.11\" - ... autoGroup: true - swd120", function (assert) {
var formattedValue = Inputmask.format("1111111.11", {
alias: "decimal",
radixPoint: ".",
digits: 2,
autoGroup: true,
groupSeparator: ",",
groupSize: 3,
allowMinus: true
});
assert.equal(formattedValue, "1,111,111.11", "Result " + formattedValue);
});
qunit.test("Inputmask.format(phone, { mask: '(999) 999-9999' })); - krivaten", function (assert) {
var phone = '5551112222';
var formattedValue = Inputmask.format(phone, {
mask: '(999) 999-9999'
});
assert.equal(formattedValue, "(555) 111-2222", "Result " + formattedValue);
});
qunit.test("format(62.91, { alias: 'numeric' } - penihel", function (assert) {
var formattedValue = Inputmask.format(62.91, {alias: 'numeric'});
assert.equal(formattedValue, "62.91", "Result " + formattedValue);
});
qunit.module("Value Validating");
qunit.test("Inputmask.isValid(\"23/03/1973\", { alias: \"datetime\"})", function (assert) {
var isValid = Inputmask.isValid("23/03/1973", {
alias: "datetime",
inputFormat: "dd/mm/yyyy"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("Inputmask.isValid(\"01 650 103 002 0001 DE101 5170\", { mask: \"99 999 999 999 9999 \\D\\E*** 9999\"})", function (assert) {
var isValid = Inputmask.isValid("01 650 103 002 0001 DE101 5170", {
mask: "99 999 999 999 9999 \\D\\E*** 9999"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("Inputmask.isValid email => false", function (assert) {
var isValid = Inputmask.isValid("some.body@mail.c", {
alias: "email"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("Inputmask.isValid email => true", function (assert) {
var isValid = Inputmask.isValid("some.body@mail.com", {
alias: "email"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("Inputmask.isValid email greedy => false", function (assert) {
var isValid = Inputmask.isValid("some.body@mail.c", {
alias: "email",
greedy: true
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("Inputmask.isValid email greedy => true", function (assert) {
var isValid = Inputmask.isValid("some.body@mail.com", {
alias: "email",
greedy: true
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"100\", { alias: \"integer\" }", function (assert) {
var isValid = Inputmask.isValid("100", {
alias: "integer"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"100.00\", { alias: \"integer\" }", function (assert) {
var isValid = Inputmask.isValid("100.00", {
alias: "integer"
});
assert.equal(isValid, false, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"123\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("123", {
alias: "decimal"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"123.45\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("123.45", {
alias: "decimal"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"123456.78\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("123456.78", {
alias: "decimal"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"123,456.78\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("123,456.78", {
alias: "decimal",
radixPoint: ".",
groupSeparator: ","
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"12,\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("12,", {
alias: "decimal",
radixPoint: ".",
groupSeparator: ",",
groupSize: 3
});
assert.equal(isValid, false, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"12,1.45\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("12,1.45", {
alias: "decimal",
radixPoint: ".",
groupSeparator: ","
});
assert.equal(isValid, false, "Result " + isValid);
});
qunit.test("YoussefTaghlabi isValid(\"12,345.67\", { alias: \"decimal\" }", function (assert) {
var isValid = Inputmask.isValid("12,345.67", {
alias: "decimal",
radixPoint: ".",
groupSeparator: ","
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("thomstark isValid(\"12lbs\", {mask:\"99[9]lb\\s\", greedy:false, skipOptionalPartCharacter: \"\", \"clearIncomplete\":true}", function (assert) {
var isValid = Inputmask.isValid("12lbs", {
mask: "99[9]lb\\s",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("thomstark isValid(\"1'2\"\", {mask:\"9'9[9]\"\", greedy:false, skipOptionalPartCharacter: \"\", \"clearIncomplete\":true}", function (assert) {
var isValid = Inputmask.isValid("1'2\"", {
mask: "9'9[9]\"",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("thomstark isValid(\"12lbs\", {mask:\"99{1,2}lb\\s\", greedy:false, skipOptionalPartCharacter: \"\", \"clearIncomplete\":true}", function (assert) {
var isValid = Inputmask.isValid("12lbs", {
mask: "99{1,2}lb\\s",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("thomstark isValid(\"9'9{1,2}\", {mask:\"9'9[9]\"\", greedy:false, skipOptionalPartCharacter: \"\", \"clearIncomplete\":true}", function (assert) {
var isValid = Inputmask.isValid("1'2\"", {
mask: "9'9{1,2}\"",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("a13x3y isValid(\"some_body@mail.com\", {alias:\"email\"}", function (assert) {
var isValid = Inputmask.isValid("some_body@mail.com", {
alias: "email"
});
assert.equal(isValid, true, "Result " + isValid);
});
qunit.test("Inputmask(\"99-99[ 99/99]\").isValid(\"03-11\") - pricejt", function (assert) {
var isValid = Inputmask("99-99[ 99/99]").isValid("03-11");
assert.equal(isValid, true, "Result " + isValid);
});
qunit.module("Value unmasking");
qunit.test("inputmask.unmask(\"23/03/1973\", { alias: \"datetime dd/mm/yyyy\" })", function (assert) {
var unmasked = Inputmask.unmask("23/03/1973", {
alias: "datetime",
inputFormat: "dd/mm/yyyy",
outputFormat: "ddmmyyyy"
});
assert.equal(unmasked, "23031973", "Result " + unmasked);
});
};

186
vendor/Inputmask/qunit/tests_initialvalue.js vendored
View File

@@ -1,186 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Initial value setting");
qunit.test("inputmask(\"999:99\", { placeholder: \"0\"}) value=\"007:20\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="007:20" />');
var testmask = document.getElementById("testmask");
Inputmask("999:99", {
placeholder: "0"
}).mask(testmask);
assert.equal(testmask.value, "007:20", "Result " + testmask.value);
});
qunit.test("inputmask(\"99 999 999 999 9999 \\D\\E*** 9999\") ~ value=\"01 650 103 002 0001 DE101 5170\" - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="01 650 103 002 0001 DE101 5170" />');
var testmask = document.getElementById("testmask");
Inputmask("99 999 999 999 9999 \\D\\E*** 9999").mask(testmask);
assert.equal(testmask.value, "01 650 103 002 0001 DE101 5170", "Result " + testmask.value);
});
qunit.test("inputmask(\"99 999 999 999 9999 \\D\\E*** 9999\") ~ value=\"016501030020001DE1015170\" - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="016501030020001DE1015170" />');
var testmask = document.getElementById("testmask");
Inputmask("99 999 999 999 9999 \\D\\E*** 9999").mask(testmask);
assert.equal(testmask.value, "01 650 103 002 0001 DE101 5170", "Result " + testmask.value);
});
qunit.test("inputmask(\"99 999 999 999 9999 \\D\\E*** 9999\") ~ value=\"016501030020001DE1015170\" replace 2 with 3 - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="016501030020001DE1015170" />');
var testmask = document.getElementById("testmask");
Inputmask("99 999 999 999 9999 \\D\\E*** 9999").mask(testmask);
$.caret(testmask, 13, 14);
$("#testmask").Type("3");
assert.equal(testmask.value, "01 650 103 003 0001 DE101 5170", "Result " + testmask.value);
});
qunit.test("inputmask(\"99 999 999 999 9999 \\D\\E*** 9999\") ~ value=\"016501030020001DE1015170\" replace 002 with 003 - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="016501030020001DE1015170" />');
var testmask = document.getElementById("testmask");
Inputmask("99 999 999 999 9999 \\D\\E*** 9999").mask(testmask);
$.caret(testmask, 11, 14);
$("#testmask").Type("003");
assert.equal(testmask.value, "01 650 103 003 0001 DE101 5170", "Result " + testmask.value);
});
qunit.test("inputmask(\"99 999 999 999 9999 \\D\\E*** 9999\") ~ value=\"016501030020001DE1015170\" replace 02 with 01 - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="016501030020001DE1015170" />');
var testmask = document.getElementById("testmask");
Inputmask("99 999 999 999 9999 \\D\\E*** 9999").mask(testmask);
$.caret(testmask, 12, 14);
$("#testmask").Type("01");
assert.equal(testmask.value, "01 650 103 001 0001 DE101 5170", "Result " + testmask.value);
});
qunit.test("inputmask(\"99 999 999 999 9999 \\D\\E*** 9999\", { greedy: false }) ~ value=\"016501030020001DE1015170\" replace 02 with 01 - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="016501030020001DE1015170" />');
var testmask = document.getElementById("testmask");
Inputmask("99 999 999 999 9999 \\D\\E*** 9999", {
greedy: false
}).mask(testmask);
$.caret(testmask, 12, 14);
$("#testmask").Type("01");
assert.equal(testmask.value, "01 650 103 001 0001 DE101 5170", "Result " + testmask.value);
});
qunit.test("inputmask(\"\\D\\E***\") ~ value=\"DE001\" - wuSam", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="DE001" />');
var testmask = document.getElementById("testmask");
Inputmask("\\D\\E***").mask(testmask);
assert.equal(testmask.value, "DE001", "Result " + testmask.value);
});
qunit.test("inputmask(\"decimal\") ~ value=\"123.45\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="123.45" />');
var testmask = document.getElementById("testmask");
Inputmask("decimal").mask(testmask);
assert.equal(testmask.value, "123.45", "Result " + testmask.value);
});
qunit.test("inputmask(\"decimal\") ~ value=\"123.45\" - disabled input", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="123.45" disabled="disabled" />');
var testmask = document.getElementById("testmask");
Inputmask("decimal").mask(testmask);
assert.equal(testmask.value, "123.45", "Result " + testmask.value);
});
qunit.test("datetime inputformat mm/yyyy ~ value=\"031973\" - disabled input", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="031973" disabled="disabled" />');
var testmask = document.getElementById("testmask");
Inputmask("datetime", {
inputFormat: "mm/yyyy"
}).mask(testmask);
assert.equal(testmask.value, "03/1973", "Result " + testmask.value);
});
qunit.test("inputmask(\"6703 9999 9999 9999 9\") ~ value=\"6703 1234 5678 9012 3\" - FransVdb", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="6703 1234 5678 9012 3" />');
Inputmask("6703 9999 9999 9999 9");
assert.equal(testmask.value, "6703 1234 5678 9012 3", "Result " + testmask.value);
});
qunit.test("inputmask(\"6703 9999 9999 9999 9\") ~ type \"6703 1234 5678 9012 3\" + backspace - FransVdb", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("6703 9999 9999 9999 9").mask(testmask);
testmask.focus();
$("#testmask").Type("1234567890123");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "6703 1234 5678 9012 _", "Result " + testmask.value);
});
qunit.test("inputmask(\"6703 9999 9999 9999 9\") ~ type \"6703670367036\" + backspace - FransVdb", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("6703 9999 9999 9999 9").mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
setTimeout(function () {
$("#testmask").Type("6703670367036");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "6703 6703 6703 6703 _", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("f\\\\acebook.com/&{0,20} value=\"event\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="event" />');
var testmask = document.getElementById("testmask");
Inputmask(
{mask:'f\\acebook.com/&{0,20}'}
).mask(testmask);
assert.equal(testmask.value, "facebook.com/EVENT", "Result " + testmask.value);
});
qunit.test("f\\\\acebook.com/&{0,20} value=\"event\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="facebook.com/EVENT" />');
var testmask = document.getElementById("testmask");
Inputmask(
{mask:'f\\acebook.com/&{0,20}'}
).mask(testmask);
assert.equal(testmask.value, "facebook.com/EVENT", "Result " + testmask.value);
});
qunit.test("f\\\\acebook.com/&{0,20} value=\"facet\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="facet" />');
var testmask = document.getElementById("testmask");
Inputmask(
{mask:'f\\acebook.com/&{0,20}'}
).mask(testmask);
assert.equal(testmask.value, "facebook.com/FACET", "Result " + testmask.value);
});
qunit.test("f\\\\acebook.com/&{0,20} value=\"facebook.com/facet\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="facebook.com/facet" />');
var testmask = document.getElementById("testmask");
Inputmask(
{mask:'f\\acebook.com/&{0,20}'}
).mask(testmask);
assert.equal(testmask.value, "facebook.com/FACET", "Result " + testmask.value);
});
};

125
vendor/Inputmask/qunit/tests_inputeventonly.js vendored
View File

@@ -1,125 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("inputEventOnly: true");
qunit.test("XXX-9999-9999-XXX-XXX - gersteba", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
inputEventOnly: true,
mask: "XXX-9999-9999-XXX-XXX",
definitions: {
"X": {
validator: "[A-Ha-hJ-Nj-nPpR-Zr-z2-9]",
cardinality: 1,
casing: "upper"
}
}
}).mask(testmask);
testmask.focus();
//simulate input
$(testmask).input("abc12341234abcabc");
assert.equal(testmask.value, "ABC-1234-1234-ABC-ABC", "Result " + testmask.value);
});
qunit.test("(999) 999-9999", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999) 999-9999", {inputEventOnly: true}).mask(testmask);
testmask.focus();
//simulate input
$(testmask).input("1231231234");
assert.equal(testmask.value, "(123) 123-1234", "Result " + testmask.value);
});
qunit.test("(999) 999-9999 - type 123 + backspace", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(999) 999-9999", {inputEventOnly: true}).mask(testmask);
testmask.focus();
//simulate input
$(testmask).input("123");
//simulate backspace
$(testmask).input("(12) ___-____", 3);
assert.ok($.caret(testmask).begin == 3, "Caret " + $.caret(testmask).begin);
});
qunit.test("9999\\9\\9 - type 1234 + backspace - NightsDream", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"mask": "9999\\9\\9",
clearMaskOnLostFocus: false,
placeholder: "X",
colorMask: true,
inputEventOnly: true
}).mask(testmask);
testmask.focus();
//simulate input
$(testmask).input("123499");
//simulate backspace
$(testmask).input("12349", 5);
assert.ok($.caret(testmask).begin == 3, "Caret " + $.caret(testmask).begin);
});
qunit.test("numeric placeholder 0 - alexey-m-ukolov", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
alias: "numeric",
placeholder: "0",
inputEventOnly: true,
colorMask: true,
androidHack: "rtfm"
}, {inputEventOnly: true}).mask(testmask);
testmask.focus();
setTimeout(function () {
$(testmask).Type("10");
assert.equal(testmask.value, "10", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("numeric 1 - #1617", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("numeric", {
groupSeparator: ".",
radixPoint: ",",
placeholder: "0",
autoGroup: true,
digits: 2,
digitsOptional: false,
clearMaskOnLostFocus: false,
inputEventOnly: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$.caret(testmask, 0);
$(testmask).Type("56,03");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$(testmask).Type("0,03");
assert.equal(testmask.value, "50,03", "Result " + testmask.value);
done();
}, 0);
});
};

96
vendor/Inputmask/qunit/tests_ip.js vendored
View File

@@ -1,96 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("IP - masks");
qunit.test("inputmask(\"ip\" - 10.10.10.10", function(assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
$fixture.append('<input type="text" id="testmask2" />');
var testmask2 = document.getElementById("testmask2");
Inputmask("ip").mask(testmask);
testmask.focus();
$("#testmask").Type("10.10.10.10");
testmask2.focus();
setTimeout(function() {
assert.equal(testmask.value, "10.10.10.10", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"ip\" - 1.1.1.1", function(assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
$fixture.append('<input type="text" id="testmask2" />');
var testmask2 = document.getElementById("testmask2");
Inputmask("ip").mask(testmask);
testmask.focus();
$("#testmask").Type("1.1.1.1");
testmask2.focus();
setTimeout(function() {
assert.equal(testmask.value, "1.1.1.1", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"ip\" - 255.255.255.255", function(assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
$fixture.append('<input type="text" id="testmask2" />');
var testmask2 = document.getElementById("testmask2");
Inputmask("ip").mask(testmask);
testmask.focus();
$("#testmask").Type("255.255.255.255");
setTimeout(function() {
testmask2.focus();
assert.equal(testmask.value, "255.255.255.255", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"ip\" - 192.168.1.100", function(assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
$fixture.append('<input type="text" id="testmask2" />');
var testmask2 = document.getElementById("testmask2");
Inputmask("ip").mask(testmask);
testmask.focus();
$("#testmask").Type("192.168.1.100");
testmask2.focus();
setTimeout(function() {
assert.equal(testmask.value, "192.168.1.100", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"ip\" - 123123123123 - delete 2nd 1 - ", function(assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
$fixture.append('<input type="text" id="testmask2" />');
var testmask2 = document.getElementById("testmask2");
Inputmask("ip").mask(testmask);
testmask.focus();
$("#testmask").Type("123123123123");
testmask2.focus();
$.caret(testmask, 4);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
setTimeout(function() {
assert.equal(testmask.value, "123.23.123.123", "Result " + testmask.value);
done();
}, 0);
});
};

14
vendor/Inputmask/qunit/tests_jitmasking.js vendored
View File

@@ -1,14 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("JIT Masking");
qunit.test("'(.999){*}', { jitMasking: true, numericInput: true }", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('(.999){*}', { jitMasking: true, numericInput: true }).mask(testmask);
$("#testmask").Type("123456");
assert.equal($(testmask).val(), "123.456", "Result " + $(testmask).val());
});
};

17
vendor/Inputmask/qunit/tests_jquery_inputmask.js vendored
View File

@@ -1,17 +0,0 @@
require("../lib/jquery.inputmask");
export default function (qunit, $, Inputmask) {
qunit.module("jquery.inputmask plugin");
qunit.test("", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
$("#testmask").inputmask({"mask": "99-9999-99"});
$("#testmask").focus();
setTimeout(function () {
assert.equal($("#testmask")[0].inputmask._valueGet(), "__-____-__", "Result " + $("#testmask")[0].inputmask._valueGet());
done();
}, 0);
});
};

368
vendor/Inputmask/qunit/tests_keepStatic.js vendored
View File

@@ -1,368 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("keepStatic mask switching");
qunit.test("{ mask: [\"+55-99-9999-9999\", \"+55-99-99999-9999\", ], keepStatic: true }", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["+55-99-9999-9999", "+55-99-99999-9999"],
keepStatic: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12123451234");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "+55-12-12345-1234", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ mask: \"+55-99-9999|(99)-9999\", keepStatic: true } - type 12123451234", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "+55-99-9999|(99)-9999",
keepStatic: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12123451234");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "+55-12-12345-1234", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ mask: ['(99) 9999-9999', '(99) 99999-9999'] } - val('1212341234')", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["(99) 9999-9999", "(99) 99999-9999"]
}).mask(testmask);
$("#testmask").val("1212341234");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "(12) 1234-1234", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ mask: \"+55-99-9999|(99)-9999\", keepStatic: false } type 12123451234", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "+55-99-9999|(99)-9999",
keepStatic: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12123451234");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "+55-12-12345-1234", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ mask: [\"+55-99-9999-9999\", \"+55-99-99999-9999\", ], keepStatic: true } - type 12123451234 + backspace", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["+55-99-9999-9999", "+55-99-99999-9999"],
keepStatic: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12123451234");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "+55-12-1234-5123", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ mask: [\"99-9999-99\",\"99-99999-99\"] } - type 12123412 + add 1 upfront", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99-9999-99", "99-99999-99"]
}).mask(testmask);
$("#testmask").Type("12123412");
$.caret(testmask, 0);
$("#testmask").Type("1");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "11-21234-12", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ mask: [\"99-99999-9\",\"99-999999-9\"] } - type 121234561", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99-99999-9", "99-999999-9"]
}).mask(testmask);
$("#testmask").Type("121234561");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "12-123456-1", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("{ \"keepStatic\": true, greedy: false, mask: \"(99-9)|(99999)\" } - type 12345", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"keepStatic": true,
greedy: false,
"mask": "(99-9)|(99999)"
}).mask(testmask);
$("#testmask").Type("12345");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "12345", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("7|8 999 99 99 - hiddenman", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("7|8 999 99 99").mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "_ ___ __ __", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("7|8 999 99 99 type 7 - hiddenman", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("7|8 999 99 99").mask(testmask);
$("#testmask").Type("7");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "7 ___ __ __", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("7|8 999 99 99 type 8 - hiddenman", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("7|8 999 99 99").mask(testmask);
$("#testmask").Type("8");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "8 ___ __ __", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(78)|(79) 999 99 99", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(78)|(79) 999 99 99").mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "7_ ___ __ __", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("(78)|(79) 999 99 99 - type 5", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(78)|(79) 999 99 99").mask(testmask);
testmask.focus();
$("#testmask").Type("5");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "75 ___ __ __", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(78)|(74) 999 99 99", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(78)|(74) 999 99 99").mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "7_ ___ __ __", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("5-9|(9a)-5 - keepstatic: false", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "5-9|(9a)-5",
keepStatic: false
}).mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "5-_-5", "Result " + document.getElementById("testmask").inputmask._valueGet());
done();
}, 0);
});
qunit.test("['(99) 9999-9999', '(99) 9-9999-9999'] - type 12123412345 - 3m0", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["(99) 9999-9999", "(99) 9-9999-9999"],
removeMaskOnSubmit: false,
clearmaskonlostfocus: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12123412345");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "(12) 1-2341-2345", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("['(99) 9999-9999', '(99) 9-9999-9999'] - type 12123412345 - backspace - 3m0", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["(99) 9999-9999", "(99) 9-9999-9999"],
removeMaskOnSubmit: false,
clearmaskonlostfocus: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12123412345");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "(12) 1234-1234", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(99 99)|(*****) keepStatic false - type 12 abc", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99)|(*****)", {
keepStatic: false
}).mask(testmask);
$("#testmask").Type("12 abc");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "12 __", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(99 99)|(*****) keepStatic false - type 12 123", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99)|(*****)", {
keepStatic: false
}).mask(testmask);
$("#testmask").Type("12 123");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "12 12", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(99 99)|(*****) keepStatic true - type 1212", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99)|(*****)", {
keepStatic: true
}).mask(testmask);
$("#testmask").Type("1212");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "12 12", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(99 99)|(*****) keepStatic true - type 12123", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99)|(*****)", {
keepStatic: true
}).mask(testmask);
$("#testmask").Type("12123");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "12123", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("(99 99)|(*****) keepStatic true - type abcde", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99)|(*****)", {
keepStatic: true
}).mask(testmask);
$("#testmask").Type("abcde");
assert.equal(document.getElementById("testmask").inputmask._valueGet(), "abcde", "Result " + document.getElementById("testmask").inputmask._valueGet());
});
qunit.test("[\"9+9\", \"(99)+99+99\"] keepStatic true - type 123 - ishytow", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["9+9", "(99)+99+99"], {
keepStatic: true
}).mask(testmask);
$("#testmask").Type("123");
assert.equal(testmask.value, "(12)+3_+__", "Result " + testmask.value);
});
qunit.test("[\"9+9\", \"99+99\", \"(99)+99+99\"] keepStatic true - type 12345 - ishytow", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["9+9", "99+99", "(99)+99+99"], {
keepStatic: true
}).mask(testmask);
$("#testmask").Type("12345");
assert.equal(testmask.value, "(12)+34+5_", "Result " + testmask.value);
});
qunit.test("[\"9+9\", \"99+99\", \"(99)+99+99\"] keepStatic true - type 1234 - ishytow", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["9+9", "99+99", "(99)+99+99"], {
keepStatic: true
}).mask(testmask);
$("#testmask").Type("1234");
assert.equal(testmask.value, "12+34", "Result " + testmask.value);
});
qunit.test("[\"999-9999\", \"(999) 999-9999\", \"1-(999) 999-9999\"] - 999-9999 - carylewis", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["999-9999", "(999) 999-9999", "1-(999) 999-9999"]).mask(testmask);
$("#testmask").Type("1231234");
assert.equal(testmask.value, "123-1234", "Result " + testmask.value);
});
qunit.test("[\"999-9999\", \"(999) 999-9999\", \"1-(999) 999-9999\"] - (999) 999-9999 - carylewis", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["999-9999", "(999) 999-9999", "1-(999) 999-9999"]).mask(testmask);
$("#testmask").Type("1231231234");
assert.equal(testmask.value, "(123) 123-1234", "Result " + testmask.value);
});
qunit.test("[\"999-9999\", \"(999) 999-9999\", \"1-(999) 999-9999\"] - 1-(999) 999-9999 - carylewis", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["999-9999", "(999) 999-9999", "1-(999) 999-9999"]).mask(testmask);
$("#testmask").Type("11231231234");
assert.equal(testmask.value, "1-(123) 123-1234", "Result " + testmask.value);
});
};

442
vendor/Inputmask/qunit/tests_multi.js vendored
View File

@@ -1,442 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("multi masks");
qunit.test("inputmask({ mask: [\"99-99\", \"999-99\"]}) - input 12345", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99-99", "999-99"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345");
setTimeout(function () {
assert.equal(testmask.value, "123-45", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"999.999.999-99\", \"99.999.999/9999-99\"]}) - input 12312312312", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["999.999.999-99", "99.999.999/9999-99"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12312312312");
setTimeout(function () {
assert.equal(testmask.value, "123.123.123-12", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"999.999.999-99\", \"99.999.999/9999-99\"]}) - input 12.123123123412", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["999.999.999-99", "99.999.999/9999-99"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12.123123123412");
setTimeout(function () {
assert.equal(testmask.value, "12.123.123/1234-12", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\"]]}) - input 12345 greedy + blur", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345");
testmask.blur();
setTimeout(function () {
assert.equal(testmask.inputmask._valueGet(), "12345", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\"]]}) - input 12345 not greedy", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999"],
greedy: false,
keepStatic: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345");
setTimeout(function () {
assert.equal(testmask.value, "12345", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\"]]}) - input 12345-1234", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345-1234");
setTimeout(function () {
assert.equal(testmask.value, "12345-1234", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\"]]}) - input 123451234", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123451234");
setTimeout(function () {
assert.equal(testmask.value, "12345-1234", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\"]]}) - input 1234512", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("1234512");
setTimeout(function () {
assert.equal(testmask.value, "12345-12__", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\", \"999999-9999\"]]}) - input 1234561234", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999", "999999-9999"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("1234561234");
setTimeout(function () {
assert.equal(testmask.value, "123456-1234", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\", \"999999-9999\"]]}) - input 12345-6", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999", "999999-9999"]
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345-6");
setTimeout(function () {
assert.equal(testmask.value, "12345-6___", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\", \"999999-9999\"] , keepStatic: true}) - input 123456", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999", "999999-9999"],
keepStatic: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456");
setTimeout(function () {
assert.equal(testmask.value, "12345-6___", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\", \"999999-9999\"], keepStatic: false}) - input 123456", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999", "999999-9999"],
keepStatic: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456");
setTimeout(function () {
assert.equal(testmask.value, "123456-____", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: [\"99999\", \"99999-9999\", \"999999-9999\"]]}) - input 123456 (rtl)", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" dir=\"rtl\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99999", "99999-9999", "999999-9999"]
}).mask(testmask);
testmask.focus();
setTimeout(function () { //needed to pass on ie
$("#testmask").Type("123456");
setTimeout(function () {
assert.equal(testmask.value, "___65-4321", "Result " + testmask.value);
done();
}, 0);
}, 0);
});
qunit.test("inputmask({ mask: ['9 AAA-AAA', 'A 999-999'] }) ", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["9 AAA-AAA", "A 999-999"]
}).mask(testmask);
$("#testmask").Type("1abc");
setTimeout(function () {
assert.equal(testmask.value, "1 ABC-___", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: ['9 AAA-AAA', 'A 999-999'] }) ", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["9 AAA-AAA", "A 999-999"]
}).mask(testmask);
$("#testmask").Type("a123");
setTimeout(function () {
assert.equal(testmask.value, "A 123-___", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: ['99.9', 'X'}) - annames", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: ["99.9", "X", "abc"],
definitions: {
"X": {
validator: "[xX]",
cardinality: 1,
casing: "upper"
}
}
}).mask(testmask);
$("#testmask").Type("x");
assert.equal(testmask.value, "X", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: [{ \"mask\": \"###-##-####\" }]) - lynxlive", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
var ssns = [{
"mask": "###-##-####"
}];
Inputmask({
mask: ssns,
greedy: false,
definitions: {
"#": {
validator: "[0-9]",
cardinality: 1
}
}
}).mask(testmask);
$("#testmask").Type("123121234");
assert.equal(testmask.value, "123-12-1234", "Result " + testmask.value);
});
qunit.test("'[9-]AAA-999', '999999' - type 1A - dekdegiv", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"mask": ["[9-]AAA-999", "999999"],
keepStatic: false
}).mask(testmask);
$("#testmask").Type("1a");
assert.equal(testmask.value, "1-A__-___", "Result " + testmask.value);
});
qunit.test("(99 99 999999)|(*{+}) - 12abc - dekdegiv", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99 999999)|(*{+})").mask(testmask);
$("#testmask").Type("12abc");
assert.equal(testmask.value, "12abc", "Result " + testmask.value);
});
qunit.test("(99 99 999999)|(*{+}) - 12 34 delete ' 34' + 2abc", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99 999999)|(*{+})").mask(testmask);
$("#testmask").Type("12 34");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").Type("2abc");
assert.equal(testmask.value, "122abc", "Result " + testmask.value);
});
qunit.test("(99 99 999999)|(i{+}) - 12 3abc - dekdegiv", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99 99 999999)|(*{+})", {
definitions: {
"*": {
validator: ".",
cardinality: 1,
definitionSymbol: "*"
}
},
staticDefinitionSymbol: "*"
}).mask(testmask);
$("#testmask").Type("12 3abc");
assert.equal(testmask.value, "12 3abc", "Result " + testmask.value);
});
qunit.test("[\"(99) 9999-9999\",\"(99) 99999-9999\"] - 12123451234 - click front - asyncerror", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["(99) 9999-9999", "(99) 99999-9999"]).mask(testmask);
$("#testmask").Type("12123451234");
$.caret(testmask, 0);
testmask.focus();
$("#testmask").trigger("click");
assert.equal(testmask.value, "(12) 12345-1234", "Result " + testmask.value);
});
qunit.test("[\"+7(999)999-99-99\",\"+380(99)999-99-99\",\"+375(99)999-99-99\"] - andychups", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["+7(999)999-99-99", "+380(99)999-99-99", "+375(99)999-99-99"], {
keepStatic: false
}).mask(testmask);
$("#testmask").Type("3");
setTimeout(function () {
assert.equal(testmask.inputmask._valueGet(), "+3__(__)___-__-__", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("[\"+7(999)999-99-99\",\"+380(99)999-99-99\",\"+375(99)999-99-99\"] - andychups", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask(["+7(999)999-99-99", "+380(99)999-99-99", "+375(99)999-99-99"], {
keepStatic: false
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").trigger("click");
assert.equal(testmask.inputmask._valueGet(), "+_(___)___-__-__", "Result " + testmask.inputmask._valueGet());
done();
}, 0);
});
qunit.test("(9{4} 9{4} 9{4} 9{4})|(9{4} 9{6} 9[5])|(9{9} 9{9}) - 1234123412341234 - necrosisoff ", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9{4} 9{4} 9{4} 9{4})|(9{4} 9{6} 9[5])|(9{9} 9{9})", {
"keepStatic": true
}
).mask(testmask);
testmask.focus();
$("#testmask").Type("1234123412341234");
assert.equal(testmask.inputmask._valueGet(), "1234 1234 1234 1234", "Result " + testmask.inputmask._valueGet());
});
qunit.test("(9{4} 9{4} 9{4} 9{4})|(9{4} 9{6} 9[5])|(9{9} 9{9}) - 12341234123412341 - necrosisoff ", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(9{4} 9{4} 9{4} 9{4})|(9{4} 9{6} 9[5])|(9{9} 9{9})", {
"keepStatic": true
}
).mask(testmask);
testmask.focus();
$("#testmask").Type("12341234123412341");
assert.equal(testmask.inputmask._valueGet(), "123412341 23412341_", "Result " + testmask.inputmask._valueGet());
});
};

2047
vendor/Inputmask/qunit/tests_numeric.js vendored
View File

File diff suppressed because it is too large Load Diff

401
vendor/Inputmask/qunit/tests_numericinput.js vendored
View File

@@ -1,401 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Direction RTL");
qunit.test("inputmask(\"999.999.999\") - delete 2nd with backspace, continue the mask", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" dir="rtl" />');
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").SendKey("1");
$("#testmask").SendKey("2");
$("#testmask").SendKey("3");
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey("4");
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey("5");
$("#testmask").SendKey("6");
assert.equal(testmask.value, "___._65.341", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"999.999.999\") - delete 2nd with delete, continue the mask", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" dir="rtl" />');
var testmask = document.getElementById("testmask");
Inputmask("999.999.999").mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").SendKey("1");
$("#testmask").SendKey("2");
$("#testmask").SendKey("3");
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").SendKey(Inputmask.keyCode.RIGHT);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").SendKey("4");
$("#testmask").SendKey(Inputmask.keyCode.LEFT);
$("#testmask").SendKey("5");
$("#testmask").SendKey("6");
assert.equal(testmask.value, "___._65.341", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"999-aaa-999\")", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" dir="rtl" />');
var testmask = document.getElementById("testmask");
Inputmask("999-aaa-999").mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123abc12");
assert.equal(testmask.value, "_21-cba-321", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"999-999-999\") - replace selection", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" dir="rtl" />');
var testmask = document.getElementById("testmask");
Inputmask("999-999-999").mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123456789");
$.caret(testmask, 4, 7);
$("#testmask").Type("5");
assert.equal(testmask.value, "__9-875-321", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"999-999-999\") - replace selection with backspace", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" dir="rtl" />');
var testmask = document.getElementById("testmask");
Inputmask("999-999-999").mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123456789");
$.caret(testmask, 4, 7);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").Type("5");
assert.equal(testmask.value, "__9-875-321", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"999-999-999\") - replace selection - with delete", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" dir="rtl" />');
var testmask = document.getElementById("testmask");
Inputmask("999-999-999").mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123456789");
$.caret(testmask, 4, 7);
$("#testmask").SendKey(Inputmask.keyCode.DELETE);
$("#testmask").Type("5");
assert.equal(testmask.value, "__9-875-321", "Result " + testmask.value);
done();
}, 0);
});
qunit.module("Numeric Input");
qunit.test("inputmask({ mask: \"9\", numericInput: true, repeat: 10, greedy: true }); - 1234567890", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask({
mask: "9",
numericInput: true,
repeat: 10,
greedy: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("1234567890");
assert.equal(testmask.value, "1234567890", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"9\", numericInput: true, repeat: 10, greedy: true }); - replace selection", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask({
mask: "9",
numericInput: true,
repeat: 10,
greedy: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("1234567890");
$.caret(testmask, 3, 6);
$("#testmask").Type("5");
assert.equal(testmask.value, "__12357890", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"99-99-99\", numericInput: true }); - 1234567890", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99-99-99",
numericInput: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("1234567890");
assert.equal(testmask.value, "12-34-56", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"€ 999.999.999,99\", numericInput: true }); - 123", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('€ 999.999.999,99', {
numericInput: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123");
assert.equal(testmask.value, "€ ___.___.__1,23", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"€ 999.999.999,99\", numericInput: true }); - 123 position before 456", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('€ 999.999.999,99', {
numericInput: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123");
$.caret(testmask, 12);
$("#testmask").Type("456");
assert.equal(testmask.value, "€ ___.__4.561,23", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"€ 999.999.999,99\", { numericInput: true, radixPoint: \",\" }); - 123", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('€ 999.999.999,99', {
numericInput: true,
radixPoint: ","
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
;
setTimeout(function () {
$("#testmask").Type("123");
assert.equal(testmask.value, "€ ___.___.__1,23", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"€ 999.999.999,99\", { numericInput: true, radixPoint: \",\" }); - 123,45", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('€ 999.999.999,99', {
numericInput: true,
radixPoint: ","
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
;
setTimeout(function () {
$("#testmask").Type("123,45");
assert.equal(testmask.value, "€ ___.___.123,45", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"9999 t\", { numericInput: true }); - 123 - Joe Rosa", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('9999 t', {
numericInput: true
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
setTimeout(function () {
$("#testmask").Type("123");
assert.equal(testmask.value, "_123 t", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"9999 t\", { numericInput: true, autoUnmask: true }); - 70 - Joe Rosa", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('9999 t', {
numericInput: true,
autoUnmask: true
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
setTimeout(function () {
$("#testmask").Type("70");
assert.equal(testmask.value, "70", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask({ mask: \"['$9.99', '$99.99', '$999.99', '$9,999.99', '$99,999.99', '$999,999.99', '$9,999,999.99', '$99,999,999.99', '$999,999,999.99'], 'placeholder': ' ', 'numericInput': true, 'rightAlignNumerics': false\" value=\"$100000.00\"", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" data-inputmask=\"'mask': ['$9.99', '$99.99', '$999.99', '$9,999.99', '$99,999.99', '$999,999.99', '$9,999,999.99', '$99,999,999.99', '$999,999,999.99'], 'placeholder': ' ', 'numericInput': true, 'rightAlignNumerics': false\" value=\"$100000.00\"/>");
var testmask = document.getElementById("testmask");
Inputmask().mask(testmask);
setTimeout(function () {
assert.equal(testmask.value, "$100,000.00", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("cuurency - numericInput: true - 123456 backspace x4", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("currency", {
numericInput: true
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123456");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.value, "$ 0.12", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("decimal - numericInput: true - initial value 20,00 - Inkeliz", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="20,00" />');
var testmask = document.getElementById("testmask");
Inputmask('decimal', {
radixPoint: ',',
rightAlign: false,
showMaskOnHover: false,
numericInput: true,
allowPlus: false,
rightAlignNumerics: false,
greedy: false
}).mask(testmask);
assert.equal(testmask.value, "20,00", "Result " + testmask.value);
});
qunit.test("currency - numericInput: true - initial value 4545.56 - sadhuria", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" value="4545.56" />');
var testmask = document.getElementById("testmask");
Inputmask("currency", {
groupSeparator: ',',
placeholder: '0.00',
numericInput: true,
}).mask(testmask);
assert.equal(testmask.value, "$ 4,545.56", "Result " + testmask.value);
});
qunit.test("(,999){+|1}.99 - Baiquan", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("(,999){+|1}.99", {
numericInput: true,
placeholder: "0"
}).mask(testmask);
testmask.focus();
$("#testmask").trigger("click");
setTimeout(function () {
$("#testmask").Type("123456");
assert.equal(testmask.value, "1,234.56", "Result " + testmask.value);
done();
}, 0);
});
};

15
vendor/Inputmask/qunit/tests_option.js vendored
View File

@@ -1,15 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Extra options after masking");
qunit.test("decimal alias add suffix later - gkostov", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask({alias: "decimal", suffix: ""}).mask("testmask");
testmask.inputmask.option({suffix: "%"});
$("#testmask").Type("123.45");
assert.equal(testmask.value, "123.45%", "Result " + testmask.value);
});
};

314
vendor/Inputmask/qunit/tests_optional.js vendored
View File

@@ -1,314 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Optional");
qunit.test("inputmask(\"(99) 9999[9]-99999\") - input 121234-12345", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99) 9999[9]-99999").mask(testmask);
testmask.focus();
$("#testmask").Type("121234-12345");
assert.equal(testmask.value, "(12) 1234-12345", "Result " + testmask.value);
});
qunit.test("inputmask(\"(99) 9999[9]-99999\") - input 121234512345", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("(99) 9999[9]-99999").mask(testmask);
testmask.focus();
$("#testmask").Type("121234512345");
assert.equal(testmask.value, "(12) 12345-12345", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99999[-9999]\", greedy: true }) - input 123", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99999[-9999]",
greedy: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123");
assert.equal(testmask.value, "123__", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99999[-9999]\", greedy: false }) - input 123", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99999[-9999]",
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123");
assert.equal(testmask.value, "123__", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99999[-9999]\", greedy: false }) - input 12345", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99999[-9999]",
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12345");
assert.equal(testmask.value, "12345", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99999[-9999]\", greedy: false }) - input 123456", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99999[-9999]",
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456");
assert.equal(testmask.value, "12345-6___", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99999[-9999]\", greedy: false }) - input 123456789", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99999[-9999]",
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456789");
assert.equal(testmask.value, "12345-6789", "Result " + testmask.value);
});
qunit.test("inputmask(\"9[9][9] 999[9] 9999\") - input 123123 space 1234 - vipink70", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9[9][9] 999[9] 9999").mask(testmask);
testmask.focus();
$("#testmask").Type("123123");
$("#testmask").SendKey(Inputmask.keyCode.SPACE);
$("#testmask").Type("1234");
assert.equal(testmask.value, "123 123 1234", "Result " + testmask.value);
});
qunit.test("inputmask('[9-]AAA.999') ", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("[9-]AAA.999").mask(testmask);
$("#testmask").Type("1abc123");
$.caret(testmask, 4, 5);
$("#testmask").Type("d");
assert.equal(testmask.value, "1-ABD.123", "Result " + testmask.value);
});
qunit.test("inputmask('9[9]:99') ", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9[9]:99").mask(testmask);
$("#testmask").Type("3:44");
$.caret(testmask, 1);
$("#testmask").Type("3");
assert.equal(testmask.value, "33:44", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99999[-9999]\", greedy: false }) - input 123456", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99999[-9999]",
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456");
testmask.blur();
$("#testmask").trigger("mouseenter");
assert.equal(testmask.value, "12345-6___", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"9'9{1,2}\"\", greedy: false, skipOptionalPartCharacter: \"\", \"clearIncomplete\": true }) - input 12 blur - thomstark", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "9'9{1,2}\"",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12");
testmask.blur();
assert.equal(testmask.value, "1'2\"", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99{1,2}lb\\s\", greedy: false, skipOptionalPartCharacter: \"\", \"clearIncomplete\": true }) - input 12 blur - thomstark", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99{1,2}lb\\s",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12");
testmask.blur();
assert.equal(testmask.value, "12lbs", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"9'9[9]\"\", greedy: false, skipOptionalPartCharacter: \"\", \"clearIncomplete\": true }) - input 12 blur - thomstark", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "9'9[9]\"",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12");
testmask.blur();
assert.equal(testmask.value, "1'2\"", "Result " + testmask.value);
});
qunit.test("inputmask({ mask: \"99[9]lb\\s\", greedy: false, skipOptionalPartCharacter: \"\", \"clearIncomplete\": true }) - input 12 blur - thomstark", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "99[9]lb\\s",
greedy: false,
skipOptionalPartCharacter: "",
"clearIncomplete": true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12");
testmask.blur();
assert.equal(testmask.value, "12lbs", "Result " + testmask.value);
});
qunit.test(".inputmask(\"99999[-9999]\", { greedy: false }); - type 123456 backspace iscomplete?", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("99999[-9999]", {
greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.inputmask.isComplete(), true, "Result " + testmask.inputmask.isComplete());
});
qunit.test(".inputmask(\"99999[-9999]\", { greedy: false }); type 123456 backspace blur", function (assert) {
var $fixture = $("#qunit-fixture"), done = assert.async();
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("99999[-9999]", {
greedy: false
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("123456");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
testmask.blur();
setTimeout(function () {
assert.equal($("#testmask")[0].inputmask._valueGet(), "12345", "Result " + $("#testmask")[0].inputmask._valueGet());
done();
}, 0);
}, 0);
});
qunit.test(".inputmask(\"99999[-9999]\", { greedy: false, autoUnmask: true }); type 123456 backspace", function (assert) {
var $fixture = $("#qunit-fixture"), done = assert.async();
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("99999[-9999]", {
greedy: false,
autoUnmask: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123456");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
setTimeout(function () {
assert.equal(testmask.value, "12345", "Result " + testmask.value);
done();
}, 0);
});
qunit.test(".inputmask('999-999-9999[ ext 9{1,5}]'); - type 12345678901 backspace iscomplete? - antch", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("999-999-9999[ ext 9{1,5}]").mask(testmask);
testmask.focus();
$("#testmask").Type("12345678901");
$("#testmask").SendKey(Inputmask.keyCode.BACKSPACE);
assert.equal(testmask.inputmask.isComplete(), true, "Result " + testmask.inputmask.isComplete());
});
qunit.test("inputmask({ mask: \"9999[ 9999][ 9999]\"}) - input 1234 space space - GMTA", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "9999[ 9999][ 9999]"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("1234 ");
assert.equal(testmask.value, "1234", "Result " + testmask.value);
});
qunit.test("9999[ 9999][ 9999][ 9999][ 999] - Enfree", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
mask: "9999[ 9999][ 9999][ 9999][ 999]",
placeholder: "", greedy: false
}).mask(testmask);
testmask.focus();
$("#testmask").Type("45464748");
$.caret(testmask, 2);
$("#testmask").Type("0909");
assert.equal(testmask.value, "4509 0946 4748", "Result " + testmask.value);
});
};

230
vendor/Inputmask/qunit/tests_paste.js vendored
View File

@@ -1,230 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Paste value");
qunit.test("inputmask(\"+7 (999) 999-99-99\") ~ paste \"+79114041112\"", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("+7 (999) 999-99-99").mask(testmask);
testmask.focus();
$("#testmask").paste("+79114041112");
setTimeout(function () {
assert.equal(testmask.value, "+7 (911) 404-11-12", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"+7 (999) 999-99-99\") ~ paste \"+7 (9114041112___)\"", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("+7 (999) 999-99-99").mask(testmask);
testmask.focus();
$("#testmask").paste("+7 (9114041112___)");
setTimeout(function () {
assert.equal(testmask.value, "+7 (911) 404-11-12", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"+7 (999) 999-99-99\") ~ paste \"0079114041112\" - monoblaine", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("+7 (999) 999-99-99", {
onBeforePaste: function (pastedValue) {
//just simplistic for the test ;-)
var strippedValue = pastedValue.substr(3);
return strippedValue;
}
}).mask(testmask);
testmask.focus();
$("#testmask").paste("0079114041112");
setTimeout(function () {
assert.equal(testmask.value, "+7 (911) 404-11-12", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"+31 9999999999\") ~ paste \"3112345678\" - jason16v", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("+31 9999999999").mask(testmask);
testmask.focus();
$("#testmask").paste("3112345678");
setTimeout(function () {
assert.equal(testmask.value, "+31 3112345678", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("inputmask(\"+31 9999999999\") ~ paste \"+3112345678\" - jason16v", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("+31 9999999999").mask(testmask);
testmask.focus();
$("#testmask").paste("+3112345678");
setTimeout(function () {
assert.equal(testmask.value, "+31 12345678__", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("99.999.999/9999-99 numericInput ~ paste 79100085302751__-____/..__ - imbelo", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask({
"mask": "99.999.999/9999-99",
"numericInput": true
}).mask(testmask);
testmask.focus();
$("#testmask").paste("79100085302751");
setTimeout(function () {
assert.equal(testmask.value, "79.100.085/3027-51", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ $123.22 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("$123.22");
setTimeout(function () {
assert.equal(testmask.value, "$ 123.22", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ $-123.22 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("$-123.22");
setTimeout(function () {
assert.equal(testmask.value, "-$ 123.22", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ 1000.00 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("1000.00");
setTimeout(function () {
assert.equal(testmask.value, "$ 1,000.00", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ -1000.00 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("-1000.00");
setTimeout(function () {
assert.equal(testmask.value, "-$ 1,000.00", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ $1000.00 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("$1000.00");
setTimeout(function () {
assert.equal(testmask.value, "$ 1,000.00", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ $-1000.00 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("$-1000.00");
setTimeout(function () {
assert.equal(testmask.value, "-$ 1,000.00", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("currency ~ 000.02 - sjk07", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask('currency').mask(testmask);
testmask.focus();
$("#testmask").paste("000.02");
setTimeout(function () {
$(testmask).trigger("blur");
assert.equal(testmask.value, "$ 0.02", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("02.999.999 ~ paste 02.024.900 - tnavarra", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("02.999.999").mask(testmask);
testmask.focus();
$("#testmask").paste("02.024.900");
setTimeout(function () {
assert.equal(testmask.value, "02.024.900", "Result " + testmask.value);
done();
}, 0);
});
qunit.test("R9999999999 ~ paste 1234567890 - s-a", function (assert) {
var done = assert.async(), $fixture = $("#qunit-fixture");
$fixture.append('<input type="text" id="testmask" />');
var testmask = document.getElementById("testmask");
Inputmask("R9999999999", {
"placeholder": "0",
"showMaskOnFocus": false,
"numericInput": true
}).mask(testmask);
$("#testmask").trigger("click");
$("#testmask").paste("1234567890");
setTimeout(function () {
assert.equal(testmask.value, "R1234567890", "Result " + testmask.value);
done();
}, 0);
});
};

363
vendor/Inputmask/qunit/tests_regex.js vendored
View File

@@ -1,363 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Regex masks");
qunit.test("inputmask({ regex: \"[0-9]*\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[0-9]*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123abc45");
assert.equal(testmask.value, "12345", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[0-9]*\"}); ~ isComplete", function (assert) {
var $fixture = $("#qunit-fixture"), done = assert.async();
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[0-9]*",
oncomplete: function () {
assert.equal(testmask.value, "1", "Result " + testmask.value);
done();
}
}).mask(testmask);
testmask.focus();
$("#testmask").SendKey("1");
});
qunit.test("inputmask({ regex: \"[A-Za-z\u0410-\u044F\u0401\u04510-9]*\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[A-Za-z\u0410-\u044F\u0401\u04510-9]*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123abc45");
assert.equal(testmask.value, "123abc45", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[A-Za-z\u0410-\u044F\u0401\u0451]+[A-Za-z\u0410-\u044F\u0401\u04510-9]*\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[A-Za-z\u0410-\u044F\u0401\u0451]+[A-Za-z\u0410-\u044F\u0401\u04510-9]*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123abc45");
assert.equal(testmask.value, "abc45", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[A-Za-z\u0410-\u044F\u0401\u0451]{1}[A-Za-z\u0410-\u044F\u0401\u04510-9]*\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[A-Za-z\u0410-\u044F\u0401\u0451]{1}[A-Za-z\u0410-\u044F\u0401\u04510-9]*"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123abc45");
assert.equal(testmask.value, "abc45", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[-]?(([1-8][0-9])|[1-9]0?)\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[-]?(([1-8][0-9])|[1-9]0?)"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("90");
assert.equal(testmask.value, "90", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[-]?(([1-8][0-9])|[1-9]0?)\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[-]?(([1-8][0-9])|[1-9]0?)"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("0");
assert.equal(testmask.value, "", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[-]?(([1-8][0-9])|[1-9]0?)\"});", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[-]?(([1-8][0-9])|[1-9]0?)"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("-78");
assert.equal(testmask.value, "-78", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[a-za-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*)?\" - simple regex email", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[a-za-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*)?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("some.body@mail.com");
assert.equal(testmask.value, "some.body@mail.com", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"[a-za-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*)?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\" - complexer regex email", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[a-za-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*)?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("denise.van.de.cruys@mail.com");
assert.equal(testmask.value, "denise.van.de.cruys@mail.com", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))\" - mrpanacs regex 1-123-4562", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("1-123-4562");
assert.equal(testmask.value, "1-123-4562", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))\" - mrpanacs regex 20-222-2222", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("20-222-2222");
assert.equal(testmask.value, "20-222-2222", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))\" - mrpanacs regex 22-222-234", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("22-222-234");
assert.equal(testmask.value, "22-222-234", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))\" - mrpanacs regex 70-12-34", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(([2-9][0-9])-([0-9]{3}-[0-9]{3}))|((1|30|20|70)-([0-9]{3}-[0-9]{4}))"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("70-12-34");
assert.equal(testmask.value, "70-123-4__", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"([0-9]|[1][0-9]|[2][0-3]?)(\\.(5|25|75))?\" - arame regex 12", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "([0-9]|[1][0-9]|[2][0-3]?)(\\.(5|25|75))?"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12");
assert.equal(testmask.value, "12", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"([0-9]|[1][0-9]|[2][0-3]?)(\\.(5|25|75))?\" } - arame regex 12.5", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "([0-9]|[1][0-9]|[2][0-3]?)(\\.(5|25|75))?"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12.5");
assert.equal(testmask.value, "12.5", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"([0-9]|[1][0-9]|[2][0-3]?)(\\.(5|25|75))?\" } - arame regex 12.75", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "([0-9]|[1][0-9]|[2][0-3]?)(\\.(5|25|75))?"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("12.75");
assert.equal(testmask.value, "12.75", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(abc)+(def)\" }); - Flyarbonkers regex abcdef", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(abc)+(def)",
jitMasking: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcdef");
assert.equal(testmask.value, "abcdef", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(abc)+(def)\" }); - Flyarbonkers regex 123a4b5c6d7e8f", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(abc)+(def)",
jitMasking: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123a4b5c6d7e8f");
assert.equal(testmask.value, "abcdef", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(abc)+(def)\" }); - Flyarbonkers regex abcabcdef", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(abc)+(def)",
jitMasking: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcabcdef");
assert.equal(testmask.value, "abcabcdef", "Result " + testmask.value);
});
qunit.test("inputmask({ regex: \"(abc){2,4}(def)\" }); - Flyarbonkers regex abcafebcaefbfcabcdef", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "(abc){2,4}(def)",
jitMasking: true
}).mask(testmask);
testmask.focus();
$("#testmask").Type("abcafebcaefbfcabcdef");
assert.equal(testmask.value, "abcabcabcabcdef", "Result " + testmask.value);
});
qunit.test("inputmask({regex: \"[а-яА-Я\\s]*\"}) - type space - SilentImp", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[а-яА-Я\\s]*"
}).mask(testmask);
testmask.focus();
$("#testmask").SendKey(Inputmask.keyCode.SPACE);
assert.equal(testmask.value, " ", "Result " + testmask.value);
});
qunit.test("inputmask({regex: \"\\+7 \\(\\d{3}\\) \\d{3} \\d{4}\"}) - hxss", function (assert) {
var done = assert.async(),
$fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "\\+7 \\(\\d{3}\\) \\d{3} \\d{4}"
}).mask(testmask);
testmask.focus();
setTimeout(function () {
assert.equal(testmask.inputmask.__valueGet.call(testmask), "+7 (___) ___ ____", "Result " + testmask.inputmask.__valueGet.call(testmask));
done();
}, 0);
});
qunit.test("[0-9]{2}|[0-9]{3} - type 123", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[0-9]{2}|[0-9]{3}"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("123");
assert.equal(testmask.inputmask.__valueGet.call(testmask), "123", "Result " + testmask.inputmask.__valueGet.call(testmask));
});
qunit.test("[+-]?[0-9]+\\.?([0-9]+)?(px|em|rem|ex|%|in|cm|mm|pt|pc) - type maimairel", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask({
regex: "[+-]?[0-9]+\\.?([0-9]+)?(px|em|rem|ex|%|in|cm|mm|pt|pc)"
}).mask(testmask);
testmask.focus();
$("#testmask").Type("10px");
assert.equal(testmask.inputmask.__valueGet.call(testmask), "10px", "Result " + testmask.inputmask.__valueGet.call(testmask));
});
};

149
vendor/Inputmask/qunit/tests_setvalue.js vendored
View File

@@ -1,149 +0,0 @@
export default function (qunit, Inputmask) {
var $ = Inputmask.dependencyLib;
qunit.module("Set value with fn.val");
qunit.test("inputmask(\"decimal\") ~ value=\"123.45\"", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("decimal").mask(testmask);
$("#testmask").val("123.45");
assert.equal(testmask.value, "123.45", "Result " + testmask.value);
});
qunit.test("inputmask(\"9\") ~ value=\"1\" ", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("9").mask(testmask);
$("#testmask").val("1");
assert.equal(testmask.value, "1", "Result " + testmask.value);
});
qunit.test("inputmask(\"decimal\") ~ .val(\"123.45\") - disabled input", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" disabled=\"disabled\" />");
var testmask = document.getElementById("testmask");
Inputmask("decimal").mask(testmask);
$("#testmask").val("123.45");
assert.equal(testmask.value, "123.45", "Result " + testmask.value);
});
qunit.test("inputmask(\"mm/yyyy\") ~ .val(\"031973\") - disabled input", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" disabled=\"disabled\" />");
var testmask = document.getElementById("testmask");
Inputmask("datetime", {inputFormat: "mm/yyyy"}).mask(testmask);
$("#testmask").val("031973");
assert.equal(testmask.value, "03/1973", "Result " + testmask.value);
});
qunit.test("inputmask({ \"mask\": \"(999) 999-9999\" }) ~ .val(\"8144419449\") - type=\"tel\" - bodrick", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"tel\" id=\"testmask\" disabled=\"disabled\" />");
var testmask = document.getElementById("testmask");
Inputmask({
"mask": "(999) 999-9999"
}).mask(testmask);
$("#testmask").val("8144419449");
assert.equal(testmask.value, "(814) 441-9449", "Result " + testmask.value);
});
qunit.test(".inputmask('decimal',{ alias:\"decimal\",integerDigits:9,digits:3,digitsOptional: false,placeholder: '0' }); - '2000.000' - vijjj", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("decimal", {
alias: "decimal",
integerDigits: 9,
digits: 3,
digitsOptional: false,
placeholder: "0"
}).mask(testmask);
$("#testmask").val("2000.000");
assert.equal(testmask.value, "2000.000", "Result " + testmask.value);
});
qunit.test(".inputmask('decimal',{ alias:\"decimal\",integerDigits:9,digits:3,digitsOptional: false,placeholder: '0' }); - 3000.000 - vijjj", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("decimal", {
alias: "decimal",
integerDigits: 9,
digits: 3,
digitsOptional: false,
placeholder: "0"
}).mask(testmask);
$("#testmask").val(3000.000);
assert.equal(testmask.value, "3000.000", "Result " + testmask.value);
});
qunit.test(".inputmask('decimal',{ alias:\"decimal\",integerDigits:9,digits:3,digitsOptional: false,placeholder: '0' }); - '4000.00' - vijjj", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("decimal", {
alias: "decimal",
integerDigits: 9,
digits: 3,
digitsOptional: false,
placeholder: "0"
}).mask(testmask);
$("#testmask").val("4000.00");
assert.equal(testmask.value, "4000.000", "Result " + testmask.value);
});
qunit.test(".inputmask('decimal',{ alias:\"decimal\",integerDigits:9,digits:3,digitsOptional: false,placeholder: '0' }); - '5000.000' - vijjj", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("decimal", {
alias: "decimal",
integerDigits: 9,
digits: 3,
digitsOptional: false,
placeholder: "0"
}).mask(testmask);
document.getElementById("testmask").value = "5000.000";
assert.equal(testmask.value, "5000.000", "Result " + testmask.value);
});
qunit.test(".inputmask(\"mask\", {\"mask\": \"+7 (999) 999-99-99\"}); - \"+7 (705) 123-45-67\" - serious-andy", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("mask", {
"mask": "+7 (999) 999-99-99"
}).mask(testmask);
$("#testmask").val("+7 (705) 123-45-67");
assert.equal(testmask.value, "+7 (705) 123-45-67", "Result " + testmask.value);
});
qunit.test(".inputmask(\"mask\", {\"mask\": \"+375 (99) 999-99-99\"}); - \"+375 (37) 999-99-99\" - PavelTyk", function (assert) {
var $fixture = $("#qunit-fixture");
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("mask", {
"mask": "+375 (99) 999-99-99"
}).mask(testmask);
$("#testmask").val("+375 (37) 999-99-99");
assert.equal(testmask.value, "+375 (37) 999-99-99", "Result " + testmask.value);
});
qunit.test(".inputmask(\"mask\", {\"mask\": \"+7(999)999-99-99\"}); - '7771231234' + '' - moongrate", function (assert) {
var $fixture = $("#qunit-fixture"), done = assert.async();
$fixture.append("<input type=\"text\" id=\"testmask\" />");
var testmask = document.getElementById("testmask");
Inputmask("mask", {
"mask": "+7(999)999-99-99"
}).mask(testmask);
testmask.focus();
setTimeout(function () {
$("#testmask").Type("7771231234");
$("#testmask").val(testmask.value);
assert.equal(testmask.value, "+7(777)123-12-34", "Result " + testmask.value);
done();
}, 0);
});
};

8
vendor/Inputmask/webpack.buildconfig.js vendored
View File

@@ -1,8 +0,0 @@
var $ = require("./lib/dependencyLibs/inputmask.dependencyLib"),
webpackconfig = require("./webpack.config"),
webPackBuildConfig = $.extend(true, {}, webpackconfig);
webPackBuildConfig.optimization.minimize = true;
module.exports = webPackBuildConfig;

157
vendor/Inputmask/webpack.config.js vendored
View File

@@ -1,157 +0,0 @@
var webpack = require("webpack"),
UglifyJsPlugin = require("uglifyjs-webpack-plugin");
function createBanner() {
return "[name]\n" +
"<%= pkg.homepage %>\n" +
"Copyright (c) 2010 - <%= grunt.template.today('yyyy') %> <%= pkg.author.name %>\n" +
"Licensed under the <%= pkg.license %> license\n" +
"Version: <%= pkg.version %>";
}
var rules = {
// sourceMap: {
// enforce: 'pre',
// test: /\.js$/,
// loader: 'source-map-loader',
// },
js: {
test: /\.js$/,
loader: "babel-loader",
exclude: /(node_modules)/,
options: {
presets: [
["@babel/preset-env"]
],
passPerPreset: true,
},
},
// ts: {
// test: /\.tsx?$/,
// loader: 'awesome-typescript-loader',
// exclude: /(node_modules)/
// },
styles: {
test: /\.css$/,
use: [
"style-loader",
{
loader: "css-loader",
options: {
importLoaders: 1
}
},
{
loader: "postcss-loader",
options: {
plugins: function () {
return [
require("postcss-cssnext")
];
}
}
}
]
}
};
module.exports = {
entry: {
"dist/inputmask": "./bundle.js",
"dist/inputmask.min": "./bundle.js",
"qunit/qunit": "./qunit/index.js"
},
output: {
path: __dirname,
filename: "[name].js",
libraryTarget: "umd"
},
externals: {
"jquery": {
commonjs: "jquery",
commonjs2: "jquery",
amd: "jquery",
root: "jQuery"
},
"jqlite": "jqlite",
"qunit": "QUnit"
},
optimization: {
minimize: false,
minimizer: [new UglifyJsPlugin({
include: /\.min\.js$/,
sourceMap: false,
uglifyOptions: {
warnings: "verbose",
mangle: false,
compress: {
keep_fnames: true,
unused: false,
typeofs: false,
dead_code: false,
collapse_vars: false
},
output: {
ascii_only: true,
beautify: false,
comments: /^!/
}
},
extractComments: false
}), new UglifyJsPlugin({
exclude: /\.min\.js$/,
sourceMap: true,
uglifyOptions: {
warnings: "verbose",
mangle: false,
compress: {
keep_fnames: true,
unused: false,
typeofs: false,
dead_code: false,
collapse_vars: false
},
output: {
ascii_only: true,
beautify: true,
comments: /^!/
}
},
extractComments: false
})]
},
module: {
rules: [
// rules.sourceMap,
rules.js,
// rules.ts,
rules.styles
]
},
resolve: {
alias: {
// "./dependencyLibs/inputmask.dependencyLib": "./dependencyLibs/inputmask.dependencyLib.jquery"
// "./dependencyLibs/inputmask.dependencyLib": "./dependencyLibs/inputmask.dependencyLib.jqlite"
}
},
devtool: "source-map",
plugins: [
new webpack.BannerPlugin({
banner: createBanner(),
entryOnly: true
})
],
bail: true,
mode: "none"
// devServer: {
// publicPath: '/',
// stats: {
// colors: true
// },
// host: '0.0.0.0',
// inline: true,
// port: '8080',
// quiet: false,
// noInfo: false,
// },
};

17
vendor/Inputmask/webpack.jqueryconfig.js vendored
View File

@@ -1,17 +0,0 @@
var $ = require("./lib/dependencyLibs/inputmask.dependencyLib"),
webpackconfig = require("./webpack.config"),
webPackJqueryConfig = $.extend(true, {}, webpackconfig);
webPackJqueryConfig.optimization.minimize = true;
webPackJqueryConfig.resolve.alias = {
"./dependencyLibs/inputmask.dependencyLib": "./dependencyLibs/inputmask.dependencyLib.jquery"
};
webPackJqueryConfig.entry = {
"dist/jquery.inputmask": "./bundle.jquery.js",
"dist/jquery.inputmask.min": "./bundle.jquery.js",
"qunit/qunit": "./qunit/index.js"
};
module.exports = webPackJqueryConfig;

1990
vendor/Parsedown.php vendored
View File

File diff suppressed because it is too large Load Diff

1399
vendor/bootstrap-showpassword/bootstrap-show-password.esm.js vendored
View File

File diff suppressed because it is too large Load Diff

10
vendor/bootstrap-showpassword/bootstrap-show-password.esm.min.js vendored
View File

File diff suppressed because one or more lines are too long

1410
vendor/bootstrap-showpassword/bootstrap-show-password.js vendored
View File

File diff suppressed because it is too large Load Diff

10
vendor/bootstrap-showpassword/bootstrap-show-password.min.js vendored
View File

File diff suppressed because one or more lines are too long

7013
vendor/bootstrap/js/bootstrap.bundle.js vendored
View File

File diff suppressed because it is too large Load Diff

1
vendor/bootstrap/js/bootstrap.bundle.js.map vendored
View File

File diff suppressed because one or more lines are too long

7
vendor/bootstrap/js/bootstrap.bundle.min.js vendored
View File

File diff suppressed because one or more lines are too long

1
vendor/bootstrap/js/bootstrap.bundle.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

4435
vendor/bootstrap/js/bootstrap.js vendored
View File

File diff suppressed because it is too large Load Diff

1
vendor/bootstrap/js/bootstrap.js.map vendored
View File

File diff suppressed because one or more lines are too long

7
vendor/bootstrap/js/bootstrap.min.js vendored
View File

File diff suppressed because one or more lines are too long

1
vendor/bootstrap/js/bootstrap.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

51
vendor/bootstrap/scss/_alert.scss vendored
View File

@@ -1,51 +0,0 @@
//
// Base styles
//
.alert {
position: relative;
padding: $alert-padding-y $alert-padding-x;
margin-bottom: $alert-margin-bottom;
border: $alert-border-width solid transparent;
@include border-radius($alert-border-radius);
}
// Headings for larger alerts
.alert-heading {
// Specified to prevent conflicts of changing $headings-color
color: inherit;
}
// Provide class for links that match alerts
.alert-link {
font-weight: $alert-link-font-weight;
}
// Dismissible alerts
//
// Expand the right padding and account for the close button's positioning.
.alert-dismissible {
padding-right: $close-font-size + $alert-padding-x * 2;
// Adjust close link position
.close {
position: absolute;
top: 0;
right: 0;
padding: $alert-padding-y $alert-padding-x;
color: inherit;
}
}
// Alternate styles
//
// Generate contextual modifier classes for colorizing the alert.
@each $color, $value in $theme-colors {
.alert-#{$color} {
@include alert-variant(theme-color-level($color, $alert-bg-level), theme-color-level($color, $alert-border-level), theme-color-level($color, $alert-color-level));
}
}

54
vendor/bootstrap/scss/_badge.scss vendored
View File

@@ -1,54 +0,0 @@
// Base class
//
// Requires one of the contextual, color modifier classes for `color` and
// `background-color`.
.badge {
display: inline-block;
padding: $badge-padding-y $badge-padding-x;
@include font-size($badge-font-size);
font-weight: $badge-font-weight;
line-height: 1;
text-align: center;
white-space: nowrap;
vertical-align: baseline;
@include border-radius($badge-border-radius);
@include transition($badge-transition);
@at-root a#{&} {
@include hover-focus {
text-decoration: none;
}
}
// Empty badges collapse automatically
&:empty {
display: none;
}
}
// Quick fix for badges in buttons
.btn .badge {
position: relative;
top: -1px;
}
// Pill badges
//
// Make them extra rounded with a modifier to replace v3's badges.
.badge-pill {
padding-right: $badge-pill-padding-x;
padding-left: $badge-pill-padding-x;
@include border-radius($badge-pill-border-radius);
}
// Colors
//
// Contextual variations (linked badges get darker on :hover).
@each $color, $value in $theme-colors {
.badge-#{$color} {
@include badge-variant($value);
}
}

41
vendor/bootstrap/scss/_breadcrumb.scss vendored
View File

@@ -1,41 +0,0 @@
.breadcrumb {
display: flex;
flex-wrap: wrap;
padding: $breadcrumb-padding-y $breadcrumb-padding-x;
margin-bottom: $breadcrumb-margin-bottom;
list-style: none;
background-color: $breadcrumb-bg;
@include border-radius($breadcrumb-border-radius);
}
.breadcrumb-item {
// The separator between breadcrumbs (by default, a forward-slash: "/")
+ .breadcrumb-item {
padding-left: $breadcrumb-item-padding;
&::before {
display: inline-block; // Suppress underlining of the separator in modern browsers
padding-right: $breadcrumb-item-padding;
color: $breadcrumb-divider-color;
content: $breadcrumb-divider;
}
}
// IE9-11 hack to properly handle hyperlink underlines for breadcrumbs built
// without `<ul>`s. The `::before` pseudo-element generates an element
// *within* the .breadcrumb-item and thereby inherits the `text-decoration`.
//
// To trick IE into suppressing the underline, we give the pseudo-element an
// underline and then immediately remove it.
+ .breadcrumb-item:hover::before {
text-decoration: underline;
}
// stylelint-disable-next-line no-duplicate-selectors
+ .breadcrumb-item:hover::before {
text-decoration: none;
}
&.active {
color: $breadcrumb-active-color;
}
}

163
vendor/bootstrap/scss/_button-group.scss vendored
View File

@@ -1,163 +0,0 @@
// stylelint-disable selector-no-qualifying-type
// Make the div behave like a button
.btn-group,
.btn-group-vertical {
position: relative;
display: inline-flex;
vertical-align: middle; // match .btn alignment given font-size hack above
> .btn {
position: relative;
flex: 1 1 auto;
// Bring the hover, focused, and "active" buttons to the front to overlay
// the borders properly
@include hover {
z-index: 1;
}
&:focus,
&:active,
&.active {
z-index: 1;
}
}
}
// Optional: Group multiple button groups together for a toolbar
.btn-toolbar {
display: flex;
flex-wrap: wrap;
justify-content: flex-start;
.input-group {
width: auto;
}
}
.btn-group {
// Prevent double borders when buttons are next to each other
> .btn:not(:first-child),
> .btn-group:not(:first-child) {
margin-left: -$btn-border-width;
}
// Reset rounded corners
> .btn:not(:last-child):not(.dropdown-toggle),
> .btn-group:not(:last-child) > .btn {
@include border-right-radius(0);
}
> .btn:not(:first-child),
> .btn-group:not(:first-child) > .btn {
@include border-left-radius(0);
}
}
// Sizing
//
// Remix the default button sizing classes into new ones for easier manipulation.
.btn-group-sm > .btn { @extend .btn-sm; }
.btn-group-lg > .btn { @extend .btn-lg; }
//
// Split button dropdowns
//
.dropdown-toggle-split {
padding-right: $btn-padding-x * .75;
padding-left: $btn-padding-x * .75;
&::after,
.dropup &::after,
.dropright &::after {
margin-left: 0;
}
.dropleft &::before {
margin-right: 0;
}
}
.btn-sm + .dropdown-toggle-split {
padding-right: $btn-padding-x-sm * .75;
padding-left: $btn-padding-x-sm * .75;
}
.btn-lg + .dropdown-toggle-split {
padding-right: $btn-padding-x-lg * .75;
padding-left: $btn-padding-x-lg * .75;
}
// The clickable button for toggling the menu
// Set the same inset shadow as the :active state
.btn-group.show .dropdown-toggle {
@include box-shadow($btn-active-box-shadow);
// Show no shadow for `.btn-link` since it has no other button styles.
&.btn-link {
@include box-shadow(none);
}
}
//
// Vertical button groups
//
.btn-group-vertical {
flex-direction: column;
align-items: flex-start;
justify-content: center;
> .btn,
> .btn-group {
width: 100%;
}
> .btn:not(:first-child),
> .btn-group:not(:first-child) {
margin-top: -$btn-border-width;
}
// Reset rounded corners
> .btn:not(:last-child):not(.dropdown-toggle),
> .btn-group:not(:last-child) > .btn {
@include border-bottom-radius(0);
}
> .btn:not(:first-child),
> .btn-group:not(:first-child) > .btn {
@include border-top-radius(0);
}
}
// Checkbox and radio options
//
// In order to support the browser's form validation feedback, powered by the
// `required` attribute, we have to "hide" the inputs via `clip`. We cannot use
// `display: none;` or `visibility: hidden;` as that also hides the popover.
// Simply visually hiding the inputs via `opacity` would leave them clickable in
// certain cases which is prevented by using `clip` and `pointer-events`.
// This way, we ensure a DOM element is visible to position the popover from.
//
// See https://github.com/twbs/bootstrap/pull/12794 and
// https://github.com/twbs/bootstrap/pull/14559 for more information.
.btn-group-toggle {
> .btn,
> .btn-group > .btn {
margin-bottom: 0; // Override default `<label>` value
input[type="radio"],
input[type="checkbox"] {
position: absolute;
clip: rect(0, 0, 0, 0);
pointer-events: none;
}
}
}

137
vendor/bootstrap/scss/_buttons.scss vendored
View File

@@ -1,137 +0,0 @@
// stylelint-disable selector-no-qualifying-type
//
// Base styles
//
.btn {
display: inline-block;
font-family: $btn-font-family;
font-weight: $btn-font-weight;
color: $body-color;
text-align: center;
vertical-align: middle;
user-select: none;
background-color: transparent;
border: $btn-border-width solid transparent;
@include button-size($btn-padding-y, $btn-padding-x, $btn-font-size, $btn-line-height, $btn-border-radius);
@include transition($btn-transition);
@include hover {
color: $body-color;
text-decoration: none;
}
&:focus,
&.focus {
outline: 0;
box-shadow: $btn-focus-box-shadow;
}
// Disabled comes first so active can properly restyle
&.disabled,
&:disabled {
opacity: $btn-disabled-opacity;
@include box-shadow(none);
}
&:not(:disabled):not(.disabled):active,
&:not(:disabled):not(.disabled).active {
@include box-shadow($btn-active-box-shadow);
&:focus {
@include box-shadow($btn-focus-box-shadow, $btn-active-box-shadow);
}
}
}
// Future-proof disabling of clicks on `<a>` elements
a.btn.disabled,
fieldset:disabled a.btn {
pointer-events: none;
}
//
// Alternate buttons
//
@each $color, $value in $theme-colors {
.btn-#{$color} {
@include button-variant($value, $value);
}
}
@each $color, $value in $theme-colors {
.btn-outline-#{$color} {
@include button-outline-variant($value);
}
}
//
// Link buttons
//
// Make a button look and behave like a link
.btn-link {
font-weight: $font-weight-normal;
color: $link-color;
text-decoration: $link-decoration;
@include hover {
color: $link-hover-color;
text-decoration: $link-hover-decoration;
}
&:focus,
&.focus {
text-decoration: $link-hover-decoration;
box-shadow: none;
}
&:disabled,
&.disabled {
color: $btn-link-disabled-color;
pointer-events: none;
}
// No need for an active state here
}
//
// Button Sizes
//
.btn-lg {
@include button-size($btn-padding-y-lg, $btn-padding-x-lg, $btn-font-size-lg, $btn-line-height-lg, $btn-border-radius-lg);
}
.btn-sm {
@include button-size($btn-padding-y-sm, $btn-padding-x-sm, $btn-font-size-sm, $btn-line-height-sm, $btn-border-radius-sm);
}
//
// Block button
//
.btn-block {
display: block;
width: 100%;
// Vertically space out multiple block buttons
+ .btn-block {
margin-top: $btn-block-spacing-y;
}
}
// Specificity overrides
input[type="submit"],
input[type="reset"],
input[type="button"] {
&.btn-block {
width: 100%;
}
}

289
vendor/bootstrap/scss/_card.scss vendored
View File

@@ -1,289 +0,0 @@
//
// Base styles
//
.card {
position: relative;
display: flex;
flex-direction: column;
min-width: 0; // See https://github.com/twbs/bootstrap/pull/22740#issuecomment-305868106
word-wrap: break-word;
background-color: $card-bg;
background-clip: border-box;
border: $card-border-width solid $card-border-color;
@include border-radius($card-border-radius);
> hr {
margin-right: 0;
margin-left: 0;
}
> .list-group:first-child {
.list-group-item:first-child {
@include border-top-radius($card-border-radius);
}
}
> .list-group:last-child {
.list-group-item:last-child {
@include border-bottom-radius($card-border-radius);
}
}
}
.card-body {
// Enable `flex-grow: 1` for decks and groups so that card blocks take up
// as much space as possible, ensuring footers are aligned to the bottom.
flex: 1 1 auto;
padding: $card-spacer-x;
color: $card-color;
}
.card-title {
margin-bottom: $card-spacer-y;
}
.card-subtitle {
margin-top: -$card-spacer-y / 2;
margin-bottom: 0;
}
.card-text:last-child {
margin-bottom: 0;
}
.card-link {
@include hover {
text-decoration: none;
}
+ .card-link {
margin-left: $card-spacer-x;
}
}
//
// Optional textual caps
//
.card-header {
padding: $card-spacer-y $card-spacer-x;
margin-bottom: 0; // Removes the default margin-bottom of <hN>
color: $card-cap-color;
background-color: $card-cap-bg;
border-bottom: $card-border-width solid $card-border-color;
&:first-child {
@include border-radius($card-inner-border-radius $card-inner-border-radius 0 0);
}
+ .list-group {
.list-group-item:first-child {
border-top: 0;
}
}
}
.card-footer {
padding: $card-spacer-y $card-spacer-x;
background-color: $card-cap-bg;
border-top: $card-border-width solid $card-border-color;
&:last-child {
@include border-radius(0 0 $card-inner-border-radius $card-inner-border-radius);
}
}
//
// Header navs
//
.card-header-tabs {
margin-right: -$card-spacer-x / 2;
margin-bottom: -$card-spacer-y;
margin-left: -$card-spacer-x / 2;
border-bottom: 0;
}
.card-header-pills {
margin-right: -$card-spacer-x / 2;
margin-left: -$card-spacer-x / 2;
}
// Card image
.card-img-overlay {
position: absolute;
top: 0;
right: 0;
bottom: 0;
left: 0;
padding: $card-img-overlay-padding;
}
.card-img {
width: 100%; // Required because we use flexbox and this inherently applies align-self: stretch
@include border-radius($card-inner-border-radius);
}
// Card image caps
.card-img-top {
width: 100%; // Required because we use flexbox and this inherently applies align-self: stretch
@include border-top-radius($card-inner-border-radius);
}
.card-img-bottom {
width: 100%; // Required because we use flexbox and this inherently applies align-self: stretch
@include border-bottom-radius($card-inner-border-radius);
}
// Card deck
.card-deck {
display: flex;
flex-direction: column;
.card {
margin-bottom: $card-deck-margin;
}
@include media-breakpoint-up(sm) {
flex-flow: row wrap;
margin-right: -$card-deck-margin;
margin-left: -$card-deck-margin;
.card {
display: flex;
// Flexbugs #4: https://github.com/philipwalton/flexbugs#flexbug-4
flex: 1 0 0%;
flex-direction: column;
margin-right: $card-deck-margin;
margin-bottom: 0; // Override the default
margin-left: $card-deck-margin;
}
}
}
//
// Card groups
//
.card-group {
display: flex;
flex-direction: column;
// The child selector allows nested `.card` within `.card-group`
// to display properly.
> .card {
margin-bottom: $card-group-margin;
}
@include media-breakpoint-up(sm) {
flex-flow: row wrap;
// The child selector allows nested `.card` within `.card-group`
// to display properly.
> .card {
// Flexbugs #4: https://github.com/philipwalton/flexbugs#flexbug-4
flex: 1 0 0%;
margin-bottom: 0;
+ .card {
margin-left: 0;
border-left: 0;
}
// Handle rounded corners
@if $enable-rounded {
&:not(:last-child) {
@include border-right-radius(0);
.card-img-top,
.card-header {
// stylelint-disable-next-line property-blacklist
border-top-right-radius: 0;
}
.card-img-bottom,
.card-footer {
// stylelint-disable-next-line property-blacklist
border-bottom-right-radius: 0;
}
}
&:not(:first-child) {
@include border-left-radius(0);
.card-img-top,
.card-header {
// stylelint-disable-next-line property-blacklist
border-top-left-radius: 0;
}
.card-img-bottom,
.card-footer {
// stylelint-disable-next-line property-blacklist
border-bottom-left-radius: 0;
}
}
}
}
}
}
//
// Columns
//
.card-columns {
.card {
margin-bottom: $card-columns-margin;
}
@include media-breakpoint-up(sm) {
column-count: $card-columns-count;
column-gap: $card-columns-gap;
orphans: 1;
widows: 1;
.card {
display: inline-block; // Don't let them vertically span multiple columns
width: 100%; // Don't let their width change
}
}
}
//
// Accordion
//
.accordion {
> .card {
overflow: hidden;
&:not(:first-of-type) {
.card-header:first-child {
@include border-radius(0);
}
&:not(:last-of-type) {
border-bottom: 0;
@include border-radius(0);
}
}
&:first-of-type {
border-bottom: 0;
@include border-bottom-radius(0);
}
&:last-of-type {
@include border-top-radius(0);
}
.card-header {
margin-bottom: -$card-border-width;
}
}
}

197
vendor/bootstrap/scss/_carousel.scss vendored
View File

@@ -1,197 +0,0 @@
// Notes on the classes:
//
// 1. .carousel.pointer-event should ideally be pan-y (to allow for users to scroll vertically)
// even when their scroll action started on a carousel, but for compatibility (with Firefox)
// we're preventing all actions instead
// 2. The .carousel-item-left and .carousel-item-right is used to indicate where
// the active slide is heading.
// 3. .active.carousel-item is the current slide.
// 4. .active.carousel-item-left and .active.carousel-item-right is the current
// slide in its in-transition state. Only one of these occurs at a time.
// 5. .carousel-item-next.carousel-item-left and .carousel-item-prev.carousel-item-right
// is the upcoming slide in transition.
.carousel {
position: relative;
}
.carousel.pointer-event {
touch-action: pan-y;
}
.carousel-inner {
position: relative;
width: 100%;
overflow: hidden;
@include clearfix();
}
.carousel-item {
position: relative;
display: none;
float: left;
width: 100%;
margin-right: -100%;
backface-visibility: hidden;
@include transition($carousel-transition);
}
.carousel-item.active,
.carousel-item-next,
.carousel-item-prev {
display: block;
}
.carousel-item-next:not(.carousel-item-left),
.active.carousel-item-right {
transform: translateX(100%);
}
.carousel-item-prev:not(.carousel-item-right),
.active.carousel-item-left {
transform: translateX(-100%);
}
//
// Alternate transitions
//
.carousel-fade {
.carousel-item {
opacity: 0;
transition-property: opacity;
transform: none;
}
.carousel-item.active,
.carousel-item-next.carousel-item-left,
.carousel-item-prev.carousel-item-right {
z-index: 1;
opacity: 1;
}
.active.carousel-item-left,
.active.carousel-item-right {
z-index: 0;
opacity: 0;
@include transition(0s $carousel-transition-duration opacity);
}
}
//
// Left/right controls for nav
//
.carousel-control-prev,
.carousel-control-next {
position: absolute;
top: 0;
bottom: 0;
z-index: 1;
// Use flex for alignment (1-3)
display: flex; // 1. allow flex styles
align-items: center; // 2. vertically center contents
justify-content: center; // 3. horizontally center contents
width: $carousel-control-width;
color: $carousel-control-color;
text-align: center;
opacity: $carousel-control-opacity;
@include transition($carousel-control-transition);
// Hover/focus state
@include hover-focus {
color: $carousel-control-color;
text-decoration: none;
outline: 0;
opacity: $carousel-control-hover-opacity;
}
}
.carousel-control-prev {
left: 0;
@if $enable-gradients {
background: linear-gradient(90deg, rgba($black, .25), rgba($black, .001));
}
}
.carousel-control-next {
right: 0;
@if $enable-gradients {
background: linear-gradient(270deg, rgba($black, .25), rgba($black, .001));
}
}
// Icons for within
.carousel-control-prev-icon,
.carousel-control-next-icon {
display: inline-block;
width: $carousel-control-icon-width;
height: $carousel-control-icon-width;
background: no-repeat 50% / 100% 100%;
}
.carousel-control-prev-icon {
background-image: $carousel-control-prev-icon-bg;
}
.carousel-control-next-icon {
background-image: $carousel-control-next-icon-bg;
}
// Optional indicator pips
//
// Add an ordered list with the following class and add a list item for each
// slide your carousel holds.
.carousel-indicators {
position: absolute;
right: 0;
bottom: 0;
left: 0;
z-index: 15;
display: flex;
justify-content: center;
padding-left: 0; // override <ol> default
// Use the .carousel-control's width as margin so we don't overlay those
margin-right: $carousel-control-width;
margin-left: $carousel-control-width;
list-style: none;
li {
box-sizing: content-box;
flex: 0 1 auto;
width: $carousel-indicator-width;
height: $carousel-indicator-height;
margin-right: $carousel-indicator-spacer;
margin-left: $carousel-indicator-spacer;
text-indent: -999px;
cursor: pointer;
background-color: $carousel-indicator-active-bg;
background-clip: padding-box;
// Use transparent borders to increase the hit area by 10px on top and bottom.
border-top: $carousel-indicator-hit-area-height solid transparent;
border-bottom: $carousel-indicator-hit-area-height solid transparent;
opacity: .5;
@include transition($carousel-indicator-transition);
}
.active {
opacity: 1;
}
}
// Optional captions
//
//
.carousel-caption {
position: absolute;
right: (100% - $carousel-caption-width) / 2;
bottom: 20px;
left: (100% - $carousel-caption-width) / 2;
z-index: 10;
padding-top: 20px;
padding-bottom: 20px;
color: $carousel-caption-color;
text-align: center;
}

Some files were not shown because too many files have changed in this diff Show More