1844 lines
68 KiB
JavaScript
1844 lines
68 KiB
JavaScript
|
||
(function (root, factory) {
|
||
if (root === undefined && window !== undefined) root = window;
|
||
if (typeof define === 'function' && define.amd) {
|
||
define(["jquery","moment"], function (jquery, moment) {
|
||
return (factory(jquery, moment));
|
||
});
|
||
} else if (typeof module === 'object' && module.exports) {
|
||
var module_exports = factory(require("jquery"),require("moment"));
|
||
module.exports = module_exports;
|
||
|
||
} else {
|
||
factory(root["jquery"],root["moment"]);
|
||
}
|
||
}(this, function (jquery, moment) {
|
||
|
||
/**
|
||
* @license almond 0.3.3 Copyright jQuery Foundation and other contributors.
|
||
* Released under MIT license, http://github.com/requirejs/almond/LICENSE
|
||
*/
|
||
//Going sloppy to avoid 'use strict' string cost, but strict practices should
|
||
//be followed.
|
||
/*global setTimeout: false */
|
||
|
||
var requirejs, require, define;
|
||
(function (undef) {
|
||
var main, req, makeMap, handlers,
|
||
defined = {},
|
||
waiting = {},
|
||
config = {},
|
||
defining = {},
|
||
hasOwn = Object.prototype.hasOwnProperty,
|
||
aps = [].slice,
|
||
jsSuffixRegExp = /\.js$/;
|
||
|
||
function hasProp(obj, prop) {
|
||
return hasOwn.call(obj, prop);
|
||
}
|
||
|
||
/**
|
||
* Given a relative module name, like ./something, normalize it to
|
||
* a real name that can be mapped to a path.
|
||
* @param {String} name the relative name
|
||
* @param {String} baseName a real name that the name arg is relative
|
||
* to.
|
||
* @returns {String} normalized name
|
||
*/
|
||
function normalize(name, baseName) {
|
||
var nameParts, nameSegment, mapValue, foundMap, lastIndex,
|
||
foundI, foundStarMap, starI, i, j, part, normalizedBaseParts,
|
||
baseParts = baseName && baseName.split("/"),
|
||
map = config.map,
|
||
starMap = (map && map['*']) || {};
|
||
|
||
//Adjust any relative paths.
|
||
if (name) {
|
||
name = name.split('/');
|
||
lastIndex = name.length - 1;
|
||
|
||
// If wanting node ID compatibility, strip .js from end
|
||
// of IDs. Have to do this here, and not in nameToUrl
|
||
// because node allows either .js or non .js to map
|
||
// to same file.
|
||
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
|
||
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
|
||
}
|
||
|
||
// Starts with a '.' so need the baseName
|
||
if (name[0].charAt(0) === '.' && baseParts) {
|
||
//Convert baseName to array, and lop off the last part,
|
||
//so that . matches that 'directory' and not name of the baseName's
|
||
//module. For instance, baseName of 'one/two/three', maps to
|
||
//'one/two/three.js', but we want the directory, 'one/two' for
|
||
//this normalization.
|
||
normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
|
||
name = normalizedBaseParts.concat(name);
|
||
}
|
||
|
||
//start trimDots
|
||
for (i = 0; i < name.length; i++) {
|
||
part = name[i];
|
||
if (part === '.') {
|
||
name.splice(i, 1);
|
||
i -= 1;
|
||
} else if (part === '..') {
|
||
// If at the start, or previous value is still ..,
|
||
// keep them so that when converted to a path it may
|
||
// still work when converted to a path, even though
|
||
// as an ID it is less than ideal. In larger point
|
||
// releases, may be better to just kick out an error.
|
||
if (i === 0 || (i === 1 && name[2] === '..') || name[i - 1] === '..') {
|
||
continue;
|
||
} else if (i > 0) {
|
||
name.splice(i - 1, 2);
|
||
i -= 2;
|
||
}
|
||
}
|
||
}
|
||
//end trimDots
|
||
|
||
name = name.join('/');
|
||
}
|
||
|
||
//Apply map config if available.
|
||
if ((baseParts || starMap) && map) {
|
||
nameParts = name.split('/');
|
||
|
||
for (i = nameParts.length; i > 0; i -= 1) {
|
||
nameSegment = nameParts.slice(0, i).join("/");
|
||
|
||
if (baseParts) {
|
||
//Find the longest baseName segment match in the config.
|
||
//So, do joins on the biggest to smallest lengths of baseParts.
|
||
for (j = baseParts.length; j > 0; j -= 1) {
|
||
mapValue = map[baseParts.slice(0, j).join('/')];
|
||
|
||
//baseName segment has config, find if it has one for
|
||
//this name.
|
||
if (mapValue) {
|
||
mapValue = mapValue[nameSegment];
|
||
if (mapValue) {
|
||
//Match, update name to the new value.
|
||
foundMap = mapValue;
|
||
foundI = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (foundMap) {
|
||
break;
|
||
}
|
||
|
||
//Check for a star map match, but just hold on to it,
|
||
//if there is a shorter segment match later in a matching
|
||
//config, then favor over this star map.
|
||
if (!foundStarMap && starMap && starMap[nameSegment]) {
|
||
foundStarMap = starMap[nameSegment];
|
||
starI = i;
|
||
}
|
||
}
|
||
|
||
if (!foundMap && foundStarMap) {
|
||
foundMap = foundStarMap;
|
||
foundI = starI;
|
||
}
|
||
|
||
if (foundMap) {
|
||
nameParts.splice(0, foundI, foundMap);
|
||
name = nameParts.join('/');
|
||
}
|
||
}
|
||
|
||
return name;
|
||
}
|
||
|
||
function makeRequire(relName, forceSync) {
|
||
return function () {
|
||
//A version of a require function that passes a moduleName
|
||
//value for items that may need to
|
||
//look up paths relative to the moduleName
|
||
var args = aps.call(arguments, 0);
|
||
|
||
//If first arg is not require('string'), and there is only
|
||
//one arg, it is the array form without a callback. Insert
|
||
//a null so that the following concat is correct.
|
||
if (typeof args[0] !== 'string' && args.length === 1) {
|
||
args.push(null);
|
||
}
|
||
return req.apply(undef, args.concat([relName, forceSync]));
|
||
};
|
||
}
|
||
|
||
function makeNormalize(relName) {
|
||
return function (name) {
|
||
return normalize(name, relName);
|
||
};
|
||
}
|
||
|
||
function makeLoad(depName) {
|
||
return function (value) {
|
||
defined[depName] = value;
|
||
};
|
||
}
|
||
|
||
function callDep(name) {
|
||
if (hasProp(waiting, name)) {
|
||
var args = waiting[name];
|
||
delete waiting[name];
|
||
defining[name] = true;
|
||
main.apply(undef, args);
|
||
}
|
||
|
||
if (!hasProp(defined, name) && !hasProp(defining, name)) {
|
||
throw new Error('No ' + name);
|
||
}
|
||
return defined[name];
|
||
}
|
||
|
||
//Turns a plugin!resource to [plugin, resource]
|
||
//with the plugin being undefined if the name
|
||
//did not have a plugin prefix.
|
||
function splitPrefix(name) {
|
||
var prefix,
|
||
index = name ? name.indexOf('!') : -1;
|
||
if (index > -1) {
|
||
prefix = name.substring(0, index);
|
||
name = name.substring(index + 1, name.length);
|
||
}
|
||
return [prefix, name];
|
||
}
|
||
|
||
//Creates a parts array for a relName where first part is plugin ID,
|
||
//second part is resource ID. Assumes relName has already been normalized.
|
||
function makeRelParts(relName) {
|
||
return relName ? splitPrefix(relName) : [];
|
||
}
|
||
|
||
/**
|
||
* Makes a name map, normalizing the name, and using a plugin
|
||
* for normalization if necessary. Grabs a ref to plugin
|
||
* too, as an optimization.
|
||
*/
|
||
makeMap = function (name, relParts) {
|
||
var plugin,
|
||
parts = splitPrefix(name),
|
||
prefix = parts[0],
|
||
relResourceName = relParts[1];
|
||
|
||
name = parts[1];
|
||
|
||
if (prefix) {
|
||
prefix = normalize(prefix, relResourceName);
|
||
plugin = callDep(prefix);
|
||
}
|
||
|
||
//Normalize according
|
||
if (prefix) {
|
||
if (plugin && plugin.normalize) {
|
||
name = plugin.normalize(name, makeNormalize(relResourceName));
|
||
} else {
|
||
name = normalize(name, relResourceName);
|
||
}
|
||
} else {
|
||
name = normalize(name, relResourceName);
|
||
parts = splitPrefix(name);
|
||
prefix = parts[0];
|
||
name = parts[1];
|
||
if (prefix) {
|
||
plugin = callDep(prefix);
|
||
}
|
||
}
|
||
|
||
//Using ridiculous property names for space reasons
|
||
return {
|
||
f: prefix ? prefix + '!' + name : name, //fullName
|
||
n: name,
|
||
pr: prefix,
|
||
p: plugin
|
||
};
|
||
};
|
||
|
||
function makeConfig(name) {
|
||
return function () {
|
||
return (config && config.config && config.config[name]) || {};
|
||
};
|
||
}
|
||
|
||
handlers = {
|
||
require: function (name) {
|
||
return makeRequire(name);
|
||
},
|
||
exports: function (name) {
|
||
var e = defined[name];
|
||
if (typeof e !== 'undefined') {
|
||
return e;
|
||
} else {
|
||
return (defined[name] = {});
|
||
}
|
||
},
|
||
module: function (name) {
|
||
return {
|
||
id: name,
|
||
uri: '',
|
||
exports: defined[name],
|
||
config: makeConfig(name)
|
||
};
|
||
}
|
||
};
|
||
|
||
main = function (name, deps, callback, relName) {
|
||
var cjsModule, depName, ret, map, i, relParts,
|
||
args = [],
|
||
callbackType = typeof callback,
|
||
usingExports;
|
||
|
||
//Use name if no relName
|
||
relName = relName || name;
|
||
relParts = makeRelParts(relName);
|
||
|
||
//Call the callback to define the module, if necessary.
|
||
if (callbackType === 'undefined' || callbackType === 'function') {
|
||
//Pull out the defined dependencies and pass the ordered
|
||
//values to the callback.
|
||
//Default to [require, exports, module] if no deps
|
||
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
|
||
for (i = 0; i < deps.length; i += 1) {
|
||
map = makeMap(deps[i], relParts);
|
||
depName = map.f;
|
||
|
||
//Fast path CommonJS standard dependencies.
|
||
if (depName === "require") {
|
||
args[i] = handlers.require(name);
|
||
} else if (depName === "exports") {
|
||
//CommonJS module spec 1.1
|
||
args[i] = handlers.exports(name);
|
||
usingExports = true;
|
||
} else if (depName === "module") {
|
||
//CommonJS module spec 1.1
|
||
cjsModule = args[i] = handlers.module(name);
|
||
} else if (hasProp(defined, depName) ||
|
||
hasProp(waiting, depName) ||
|
||
hasProp(defining, depName)) {
|
||
args[i] = callDep(depName);
|
||
} else if (map.p) {
|
||
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
|
||
args[i] = defined[depName];
|
||
} else {
|
||
throw new Error(name + ' missing ' + depName);
|
||
}
|
||
}
|
||
|
||
ret = callback ? callback.apply(defined[name], args) : undefined;
|
||
|
||
if (name) {
|
||
//If setting exports via "module" is in play,
|
||
//favor that over return value and exports. After that,
|
||
//favor a non-undefined return value over exports use.
|
||
if (cjsModule && cjsModule.exports !== undef &&
|
||
cjsModule.exports !== defined[name]) {
|
||
defined[name] = cjsModule.exports;
|
||
} else if (ret !== undef || !usingExports) {
|
||
//Use the return value from the function.
|
||
defined[name] = ret;
|
||
}
|
||
}
|
||
} else if (name) {
|
||
//May just be an object definition for the module. Only
|
||
//worry about defining if have a module name.
|
||
defined[name] = callback;
|
||
}
|
||
};
|
||
|
||
requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
|
||
if (typeof deps === "string") {
|
||
if (handlers[deps]) {
|
||
//callback in this case is really relName
|
||
return handlers[deps](callback);
|
||
}
|
||
//Just return the module wanted. In this scenario, the
|
||
//deps arg is the module name, and second arg (if passed)
|
||
//is just the relName.
|
||
//Normalize module name, if it contains . or ..
|
||
return callDep(makeMap(deps, makeRelParts(callback)).f);
|
||
} else if (!deps.splice) {
|
||
//deps is a config object, not an array.
|
||
config = deps;
|
||
if (config.deps) {
|
||
req(config.deps, config.callback);
|
||
}
|
||
if (!callback) {
|
||
return;
|
||
}
|
||
|
||
if (callback.splice) {
|
||
//callback is an array, which means it is a dependency list.
|
||
//Adjust args if there are dependencies
|
||
deps = callback;
|
||
callback = relName;
|
||
relName = null;
|
||
} else {
|
||
deps = undef;
|
||
}
|
||
}
|
||
|
||
//Support require(['a'])
|
||
callback = callback || function () {};
|
||
|
||
//If relName is a function, it is an errback handler,
|
||
//so remove it.
|
||
if (typeof relName === 'function') {
|
||
relName = forceSync;
|
||
forceSync = alt;
|
||
}
|
||
|
||
//Simulate async callback;
|
||
if (forceSync) {
|
||
main(undef, deps, callback, relName);
|
||
} else {
|
||
//Using a non-zero value because of concern for what old browsers
|
||
//do, and latest browsers "upgrade" to 4 if lower value is used:
|
||
//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
|
||
//If want a value immediately, use require('id') instead -- something
|
||
//that works in almond on the global level, but not guaranteed and
|
||
//unlikely to work in other AMD implementations.
|
||
setTimeout(function () {
|
||
main(undef, deps, callback, relName);
|
||
}, 4);
|
||
}
|
||
|
||
return req;
|
||
};
|
||
|
||
/**
|
||
* Just drops the config on the floor, but returns req in case
|
||
* the config return value is used.
|
||
*/
|
||
req.config = function (cfg) {
|
||
return req(cfg);
|
||
};
|
||
|
||
/**
|
||
* Expose module registry for debugging and tooling
|
||
*/
|
||
requirejs._defined = defined;
|
||
|
||
define = function (name, deps, callback) {
|
||
if (typeof name !== 'string') {
|
||
throw new Error('See almond README: incorrect module build, no module name');
|
||
}
|
||
|
||
//This module may not have dependencies
|
||
if (!deps.splice) {
|
||
//deps is not an array, so probably means
|
||
//an object literal or factory function for
|
||
//the value. Adjust args.
|
||
callback = deps;
|
||
deps = [];
|
||
}
|
||
|
||
if (!hasProp(defined, name) && !hasProp(waiting, name)) {
|
||
waiting[name] = [name, deps, callback];
|
||
}
|
||
};
|
||
|
||
define.amd = {
|
||
jQuery: true
|
||
};
|
||
}());
|
||
|
||
define("almond", function(){});
|
||
|
||
|
||
|
||
define('component/models',[], function () {
|
||
var models = {
|
||
name: 'pignoseCalendar',
|
||
version: '1.4.27',
|
||
preference: {
|
||
supports: {
|
||
themes: ['light', 'dark', 'blue']
|
||
}
|
||
}
|
||
};
|
||
return models;
|
||
});
|
||
//# sourceMappingURL=models.js.map
|
||
;
|
||
|
||
|
||
define('component/helper',['./models'], function (models) {
|
||
var m_formatCache = {};
|
||
var m_classCache = {};
|
||
var m_subClassCache = {};
|
||
var m_regex_upper = /[A-Z]/;
|
||
|
||
var helper = function Constructor() {};
|
||
|
||
helper.format = function (format) {
|
||
if (!format) {
|
||
return '';
|
||
} else {
|
||
var args = Array.prototype.slice.call(arguments, 1);
|
||
var key = format + args.join('.');
|
||
|
||
if (m_formatCache[key]) {
|
||
return m_formatCache[key];
|
||
} else {
|
||
var len = args.length;
|
||
for (var idx = 0; idx < len; idx++) {
|
||
var value = args[idx];
|
||
format = format.replace(new RegExp('((?!\\\\)?\\{' + idx + '(?!\\\\)?\\})', 'g'), value);
|
||
}
|
||
format = format.replace(new RegExp('\\\\{([0-9]+)\\\\}', 'g'), '{$1}');
|
||
}
|
||
m_formatCache[key] = format;
|
||
return format;
|
||
}
|
||
};
|
||
|
||
helper.getClass = function (name) {
|
||
var key = [models.name, name].join('.');
|
||
|
||
if (m_classCache[key]) {
|
||
return m_classCache[key];
|
||
} else {
|
||
var chars = name.split('');
|
||
var classNames = [];
|
||
var len = chars.length;
|
||
|
||
for (var idx = 0, pos = 0; idx < len; idx++) {
|
||
var char = chars[idx];
|
||
if (m_regex_upper.test(char) === true) {
|
||
classNames[pos++] = '-';
|
||
char = char.toString().toLowerCase();
|
||
}
|
||
classNames[pos++] = char;
|
||
}
|
||
|
||
var className = classNames.join('');
|
||
m_classCache[key] = className;
|
||
return className;
|
||
}
|
||
};
|
||
|
||
helper.getSubClass = function (name) {
|
||
if (name && name.length) {
|
||
var names = name.split('');
|
||
names[0] = names[0].toUpperCase();
|
||
name = names.join('');
|
||
}
|
||
|
||
if (!m_subClassCache[name]) {
|
||
m_subClassCache[name] = helper.getClass(helper.format('{0}{1}', models.name, name));
|
||
}
|
||
return m_subClassCache[name];
|
||
};
|
||
|
||
return helper;
|
||
});
|
||
//# sourceMappingURL=helper.js.map
|
||
;
|
||
|
||
|
||
define('shim/utils',[], function () {
|
||
return {
|
||
register: function register(name, install, lib) {
|
||
if (!lib) {
|
||
var message = 'PIGNOSE Calendar needs ' + name + ' library.\nIf you want to use built-in plugin, Import dist/pignose.calendar.full.js.\nType below code in your command line to install the library.';
|
||
|
||
if (console && typeof console.error === 'function') {
|
||
console.warn(message);
|
||
console.warn('$ ' + install);
|
||
}
|
||
}
|
||
return lib;
|
||
}
|
||
};
|
||
});
|
||
//# sourceMappingURL=utils.js.map
|
||
;
|
||
|
||
|
||
define('moment',['./shim/utils'], function (utils) {
|
||
var lib = void 0;
|
||
try {
|
||
lib = moment;
|
||
} catch (e) {
|
||
;
|
||
}
|
||
return utils.register('moment', 'npm install moment --save', lib);
|
||
});
|
||
//# sourceMappingURL=moment.js.map
|
||
;
|
||
|
||
|
||
define('manager/index',['../component/helper', 'moment'], function (helper, moment) {
|
||
var m_dateCache = {};
|
||
var DateManager = function Constructor(date) {
|
||
if (!date) {
|
||
throw new Error('first parameter `date` must be gave');
|
||
}
|
||
|
||
if (date instanceof moment === false) {
|
||
if (typeof date === 'string' || typeof date === 'number') {
|
||
date = moment(date);
|
||
} else {
|
||
throw new Error('`date` option is invalid type. (date: ' + date + ').');
|
||
}
|
||
}
|
||
|
||
this.year = parseInt(date.format('YYYY'), 10);
|
||
this.month = parseInt(date.format('MM'), 10);
|
||
this.prevMonth = parseInt(date.clone().add(-1, 'months').format('MM'), 10);
|
||
this.nextMonth = parseInt(date.clone().add(1, 'months').format('MM'), 10);
|
||
this.day = parseInt(date.format('DD'), 10);
|
||
this.firstDay = 1;
|
||
this.lastDay = parseInt(date.clone().endOf('month').format('DD'), 10);
|
||
this.weekDay = date.weekday();
|
||
this.date = date;
|
||
};
|
||
|
||
DateManager.prototype.toString = function () {
|
||
return this.date.format('YYYY-MM-DD');
|
||
};
|
||
|
||
DateManager.Convert = function (year, month, day) {
|
||
var date = helper.format('{0}-{1}-{2}', year, month, day);
|
||
if (!m_dateCache[date]) {
|
||
m_dateCache[date] = moment(date, 'YYYY-MM-DD');
|
||
}
|
||
return m_dateCache[date];
|
||
};
|
||
|
||
return DateManager;
|
||
});
|
||
//# sourceMappingURL=index.js.map
|
||
;
|
||
|
||
|
||
define('component/classNames',['../component/helper'], function (helper) {
|
||
return {
|
||
top: helper.getSubClass('top'),
|
||
header: helper.getSubClass('header'),
|
||
body: helper.getSubClass('body'),
|
||
button: helper.getSubClass('button')
|
||
};
|
||
});
|
||
//# sourceMappingURL=classNames.js.map
|
||
;
|
||
|
||
|
||
define('configures/i18n',[], function () {
|
||
return {
|
||
defaultLanguage: 'en',
|
||
supports: ['en', 'ko', 'fr', 'ch', 'de', 'jp', 'pt', 'da', 'pl', 'es', 'cs', 'uk', 'ru'],
|
||
weeks: {
|
||
en: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
|
||
ko: ['일', '월', '화', '수', '목', '금', '토'],
|
||
fa: ['شنبه', 'آدینه', 'پنج', 'چهار', 'سه', 'دو', 'یک'],
|
||
fr: ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'],
|
||
ch: ['日', '一', '二', '三', '四', '五', '六'],
|
||
de: ['SO', 'MO', 'DI', 'MI', 'DO', 'FR', 'SA'],
|
||
jp: ['日', '月', '火', '水', '木', '金', '土'],
|
||
pt: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab'],
|
||
da: ['Søn', 'Man', 'Tir', 'Ons', 'Tor', 'Fre', 'Lør'],
|
||
pl: ['Nie', 'Pon', 'Wto', 'Śro', 'Czw', 'Pią', 'Sob'],
|
||
es: ['Dom', 'Lun', 'Mar', 'Mié', 'Jue', 'Vie', 'Sáb'],
|
||
it: ['Dom', 'Lun', 'Mar', 'Mer', 'Gio', 'Ven', 'Sab'],
|
||
cs: ['Ne', 'Po', 'Út', 'St', 'Čt', 'Pá', 'So'],
|
||
uk: ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Нд'],
|
||
ru: ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс']
|
||
},
|
||
monthsLong: {
|
||
en: ['January', 'February', 'March', 'April', 'May', 'Jun', 'July', 'August', 'September', 'October', 'November', 'December'],
|
||
ko: ['1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월'],
|
||
fa: ['آذر', 'آبان', 'مهر', 'شهریور', 'مرداد', 'تیر', 'خرداد', 'اردیبهشت', 'فروردین', 'اسفند', 'بهمن', 'دی'],
|
||
fr: ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre'],
|
||
ch: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
|
||
de: ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember'],
|
||
jp: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
|
||
pt: ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'],
|
||
da: ['Januar', 'Februar', 'Marts', 'April', 'Maj', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'December'],
|
||
pl: ['Styczeń', 'Luty', 'Marzec', 'Kwiecień', 'Maj', 'Czerwiec', 'Lipiec', 'Sierpień', 'Wrzesień', 'Październik', 'Listopad', 'Grudzień'],
|
||
es: ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'],
|
||
it: ['Gennaio', 'Febbraio', 'Marzo', 'Aprile', 'Maggio', 'Giugno', 'Luglio', 'Agosto', 'Settembre', 'Ottobre', 'Novembre', 'Dicembre'],
|
||
cs: ['Leden', 'Únor', 'Březen', 'Duben', 'Květen', 'Červen', 'Cervenec', 'Srpen', 'Září', 'Říjen', 'Listopad', 'Prosinec'],
|
||
uk: ['Січень', 'Лютий', 'Березень', 'Квітень', 'Травень', 'Червень', 'Липень', 'Серпень', 'Вересень', 'Жовтень', 'Листопад', 'Грудень'],
|
||
ru: ['Январь', 'Февраль', 'Март', 'Апрель', 'Май', 'Июнь', 'Июль', 'Август', 'Сентябрь', 'Октябрь', 'Ноябрь', 'Декабрь']
|
||
},
|
||
months: {
|
||
en: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
|
||
ko: ['1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월'],
|
||
fa: ['آذر', 'آبان', 'مهر', 'شهریور', 'مرداد', 'تیر', 'خرداد', 'اردیبهشت', 'فروردین', 'اسفند', 'بهمن', 'دی'],
|
||
fr: ['Jan', 'Fév', 'Mar', 'Avr', 'Mai', 'Juin', 'Juil', 'Aoû', 'Sep', 'Oct', 'Nov', 'Déc'],
|
||
ch: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
|
||
de: ['Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez'],
|
||
jp: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月'],
|
||
pt: ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'],
|
||
da: ['Jan', 'Feb', 'Mar', 'Apr', 'Maj', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dec'],
|
||
pl: ['Sty', 'Lut', 'Mar', 'Kwi', 'Maj', 'Cze', 'Lip', 'Sie', 'Wrz', 'Paź', 'Lis', 'Gru'],
|
||
es: ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dec'],
|
||
it: ['Gen', 'Feb', 'Mar', 'Apr', 'Mag', 'Giu', 'Lug', 'Ago', 'Set', 'Ott', 'Nov', 'Dic'],
|
||
cs: ['Led', 'Úno', 'Bře', 'Dub', 'Kvě', 'Čvn', 'Čvc', 'Srp', 'Zář', 'Říj', 'Lis', 'Pro'],
|
||
uk: ['Січ', 'Лют', 'Бер', 'Квіт', 'Трав', 'Черв', 'Лип', 'Серп', 'Вер', 'Жовт', 'Лист', 'Груд'],
|
||
ru: ['Янв', 'Февр', 'Март', 'Апр', 'Май', 'Июнь', 'Июль', 'Авг', 'Сент', 'Окт', 'Нояб', 'Дек']
|
||
},
|
||
controls: {
|
||
en: {
|
||
ok: 'OK',
|
||
cancel: 'Cancel'
|
||
},
|
||
ko: {
|
||
ok: '확인',
|
||
cancel: '취소'
|
||
},
|
||
fa: {
|
||
ok: 'چک کنید',
|
||
cancel: 'لغو'
|
||
},
|
||
fr: {
|
||
ok: 'Vérifier',
|
||
cancel: 'Annuler'
|
||
},
|
||
ch: {
|
||
ok: '确认',
|
||
cancel: '取消'
|
||
},
|
||
de: {
|
||
ok: 'Scheck',
|
||
cancel: 'Abbrechen'
|
||
},
|
||
jp: {
|
||
ok: '確認',
|
||
cancel: 'キャンセル'
|
||
},
|
||
pt: {
|
||
ok: 'Verifique',
|
||
cancel: 'Cancelar'
|
||
},
|
||
da: {
|
||
ok: 'Bekræftelse',
|
||
cancel: 'aflyst'
|
||
},
|
||
pl: {
|
||
ok: 'Sprawdź',
|
||
cancel: 'Anuluj'
|
||
},
|
||
es: {
|
||
ok: 'Cheque',
|
||
cancel: 'Cancelar'
|
||
},
|
||
it: {
|
||
ok: 'conferma',
|
||
cancel: 'annullato'
|
||
},
|
||
cs: {
|
||
ok: 'Zkontrolujte',
|
||
cancel: 'Zrušit'
|
||
},
|
||
uk: {
|
||
ok: 'Вибрати',
|
||
cancel: 'Скасувати'
|
||
},
|
||
ru: {
|
||
ok: 'Выбрать',
|
||
cancel: 'Отмена'
|
||
}
|
||
}
|
||
};
|
||
});
|
||
//# sourceMappingURL=i18n.js.map
|
||
;
|
||
|
||
|
||
define('component/global',['../configures/i18n'], function (languages) {
|
||
return {
|
||
language: languages.defaultLanguage,
|
||
languages: languages,
|
||
week: 0,
|
||
format: 'YYYY-MM-DD'
|
||
};
|
||
});
|
||
//# sourceMappingURL=global.js.map
|
||
;
|
||
|
||
|
||
define('component/options',['moment', './global'], function (moment, global) {
|
||
return {
|
||
lang: null,
|
||
languages: global.languages,
|
||
theme: 'light',
|
||
date: moment(),
|
||
format: global.format,
|
||
enabledDates: [],
|
||
disabledDates: [],
|
||
disabledWeekdays: [],
|
||
disabledRanges: [],
|
||
schedules: [],
|
||
scheduleOptions: {
|
||
colors: {}
|
||
},
|
||
week: global.week,
|
||
weeks: global.languages.weeks.en,
|
||
monthsLong: global.languages.monthsLong.en,
|
||
months: global.languages.months.en,
|
||
controls: global.languages.controls.en,
|
||
pickWeeks: false,
|
||
initialize: true,
|
||
multiple: false,
|
||
toggle: false,
|
||
reverse: false,
|
||
buttons: false,
|
||
modal: false,
|
||
selectOver: false,
|
||
minDate: null,
|
||
maxDate: null,
|
||
|
||
/********************************************
|
||
* EVENTS
|
||
*******************************************/
|
||
init: null,
|
||
select: null,
|
||
apply: null,
|
||
click: null,
|
||
page: null,
|
||
prev: null,
|
||
next: null
|
||
};
|
||
});
|
||
//# sourceMappingURL=options.js.map
|
||
;
|
||
|
||
|
||
define('jquery',['./shim/utils'], function (utils) {
|
||
var lib = void 0;
|
||
try {
|
||
lib = jQuery || $;
|
||
} catch (e) {
|
||
;
|
||
}
|
||
return utils.register('jquery', 'npm install jquery --save', lib);
|
||
});
|
||
//# sourceMappingURL=jquery.js.map
|
||
;
|
||
|
||
|
||
define('methods/configure',['../component/global', '../component/models', '../component/options', '../configures/i18n', 'jquery'], function (global, models, options, language, $) {
|
||
return function (settings) {
|
||
var context = this;
|
||
settings;
|
||
|
||
context.settings = $.extend(true, {}, options, settings);
|
||
|
||
if (!context.settings.lang) {
|
||
context.settings.lang = global.language;
|
||
}
|
||
|
||
if (context.settings.lang !== language.defaultLanguage && $.inArray(context.settings.lang, global.languages.supports) !== -1) {
|
||
// weeks
|
||
context.settings.weeks = global.languages.weeks[context.settings.lang] || global.languages.weeks[language.defaultLanguage];
|
||
// monthsLong
|
||
context.settings.monthsLong = global.languages.monthsLong[context.settings.lang] || global.languages.monthsLong[language.defaultLanguage];
|
||
// months
|
||
context.settings.months = global.languages.months[context.settings.lang] || global.languages.months[language.defaultLanguage];
|
||
// controls
|
||
context.settings.controls = global.languages.controls[context.settings.lang] || global.languages.controls[language.defaultLanguage];
|
||
}
|
||
|
||
if (context.settings.theme !== 'light' && $.inArray(context.settings.theme, models.preference.supports.themes) === -1) {
|
||
context.settings.theme = 'light';
|
||
}
|
||
|
||
if (context.settings.pickWeeks === true) {
|
||
if (context.settings.multiple === false) {
|
||
console.error('You must give true at settings.multiple options on PIGNOSE-Calendar for using in pickWeeks option.');
|
||
} else if (context.settings.toggle === true) {
|
||
console.error('You must give false at settings.toggle options on PIGNOSE-Calendar for using in pickWeeks option.');
|
||
}
|
||
}
|
||
|
||
context.settings.week %= context.settings.weeks.length;
|
||
};
|
||
});
|
||
//# sourceMappingURL=configure.js.map
|
||
;
|
||
|
||
|
||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
||
|
||
define('methods/init',['../manager/index', '../component/classNames', '../component/helper', '../component/models', '../component/global', './configure', 'jquery', 'moment'], function (DateManager, classNames, helper, models, global, methodConfigure, $, moment) {
|
||
var $window = $(window);
|
||
var $document = $(document);
|
||
|
||
return function (options) {
|
||
var context = this;
|
||
|
||
context.settings = {};
|
||
methodConfigure.call(context, options);
|
||
|
||
context.global = {
|
||
calendarHtml: helper.format('<div class="{0} {0}-{4}">\
|
||
<div class="{1}">\
|
||
<a href="#" class="{1}-nav {1}-prev">\
|
||
<span class="icon-arrow-left {1}-icon"></span>\
|
||
</a>\
|
||
<div class="{1}-date">\
|
||
<span class="{1}-month"></span>\
|
||
<span class="{1}-year"></span>\
|
||
</div>\
|
||
<a href="#" class="{1}-nav {1}-next">\
|
||
<span class="icon-arrow-right {1}-icon"></span>\
|
||
</a>\
|
||
</div>\
|
||
<div class="{2}"></div>\
|
||
<div class="{3}"></div>\
|
||
</div>', helper.getClass(models.name), classNames.top, classNames.header, classNames.body, context.settings.theme),
|
||
calendarButtonsHtml: helper.format('<div class="{0}-group">\
|
||
<a href="#" class="{0} {0}-cancel">{1}</a>\
|
||
<a href="#" class="{0} {0}-apply">{2}</a>\
|
||
</div>', classNames.button, context.settings.controls.cancel, context.settings.controls.ok),
|
||
calendarScheduleContainerHtml: helper.format('<div class="{0}-schedule-container"></div>', classNames.button),
|
||
calendarSchedulePinHtml: helper.format('<span class="{0}-schedule-pin {0}-schedule-pin-\\{0\\}" style="background-color: \\{1\\};"></span>', classNames.button)
|
||
};
|
||
|
||
var rangeClass = helper.getSubClass('unitRange');
|
||
var rangeFirstClass = helper.getSubClass('unitRangeFirst');
|
||
var rangeLastClass = helper.getSubClass('unitRangeLast');
|
||
var activeClass = helper.getSubClass('unitActive');
|
||
var activePositionClasses = [helper.getSubClass('unitFirstActive'), helper.getSubClass('unitSecondActive')];
|
||
var toggleActiveClass = helper.getSubClass('unitToggleActive');
|
||
var toggleInactiveClass = helper.getSubClass('unitToggleInactive');
|
||
var $calendarButton = null;
|
||
|
||
return context.each(function () {
|
||
var $this = $(this);
|
||
var local = {
|
||
initialize: null,
|
||
element: $this,
|
||
calendar: $(context.global.calendarHtml),
|
||
input: $this.is('input'),
|
||
renderer: null,
|
||
current: [null, null],
|
||
date: {
|
||
all: [],
|
||
enabled: [],
|
||
disabled: []
|
||
},
|
||
storage: {
|
||
activeDates: [],
|
||
schedules: []
|
||
},
|
||
dateManager: new DateManager(context.settings.date),
|
||
calendarWrapperHtml: helper.format('<div class="{0}"></div>', helper.getSubClass('wrapper')),
|
||
calendarWrapperOverlayHtml: helper.format('<div class="{0}"></div>', helper.getSubClass('wrapperOverlay')),
|
||
context: context
|
||
};
|
||
var $parent = $this;
|
||
|
||
if (context.settings.initialize === true) {
|
||
local.initialize = local.current[0] = local.dateManager.date.clone();
|
||
}
|
||
|
||
this.local = local;
|
||
|
||
if (context.settings.reverse === true) {
|
||
local.calendar.addClass(helper.getSubClass('reverse'));
|
||
} else {
|
||
local.calendar.addClass(helper.getSubClass('default'));
|
||
}
|
||
|
||
for (var i = context.settings.week; i < context.settings.weeks.length + context.settings.week; i++) {
|
||
if (i < 0) {
|
||
i = global.languages.weeks.en.length - i;
|
||
}
|
||
var week = context.settings.weeks[i % context.settings.weeks.length];
|
||
if (typeof week !== 'string') {
|
||
continue;
|
||
}
|
||
week = week.toUpperCase();
|
||
var $unit = $(helper.format('<div class="{0} {0}-{2}">{1}</div>', helper.getSubClass('week'), week, global.languages.weeks.en[i % global.languages.weeks.en.length].toLowerCase()));
|
||
$unit.appendTo(local.calendar.find('.' + classNames.header));
|
||
}
|
||
|
||
if (context.settings.buttons === true) {
|
||
$calendarButton = $(context.global.calendarButtonsHtml);
|
||
$calendarButton.appendTo(local.calendar);
|
||
}
|
||
|
||
if (local.input === true || context.settings.modal === true) {
|
||
var wrapperActiveClass = helper.getSubClass('wrapperActive');
|
||
var overlayActiveClass = helper.getSubClass('wrapperOverlayActive');
|
||
var $overlay = void 0;
|
||
|
||
$parent = $(local.calendarWrapperHtml);
|
||
$parent.bind('click', function (event) {
|
||
event.stopPropagation();
|
||
});
|
||
|
||
$this.bind('click', function (event) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
event.stopImmediatePropagation();
|
||
$overlay = $('.' + helper.getSubClass('wrapperOverlay'));
|
||
|
||
if ($overlay.length < 1) {
|
||
$overlay = $(local.calendarWrapperOverlayHtml);
|
||
$overlay.appendTo('body');
|
||
}
|
||
|
||
$overlay.unbind('click.' + helper.getClass(models.name)).bind('click.' + helper.getClass(models.name), function (event) {
|
||
event.stopPropagation();
|
||
$parent.trigger('cancel.' + helper.getClass(models.name));
|
||
});
|
||
|
||
if ($parent.parent().is('body') === false) {
|
||
$parent.appendTo('body');
|
||
}
|
||
|
||
$parent.show();
|
||
$overlay.show();
|
||
|
||
$window.unbind('resize.' + helper.getClass(models.name)).bind('resize.' + helper.getClass(models.name), function () {
|
||
$parent.css({
|
||
marginLeft: -$parent.outerWidth() / 2,
|
||
marginTop: -$parent.outerHeight() / 2
|
||
});
|
||
}).triggerHandler('resize.' + helper.getClass(models.name));
|
||
|
||
$this[models.name]('set', $this.val());
|
||
|
||
setTimeout(function () {
|
||
$overlay.addClass(overlayActiveClass);
|
||
$parent.addClass(wrapperActiveClass);
|
||
}, 25);
|
||
}).bind('focus', function (event) {
|
||
var $this = $(this);
|
||
$this.blur();
|
||
});
|
||
|
||
$parent.unbind('cancel.' + helper.getClass(models.name) + ' ' + 'apply.' + helper.getClass(models.name)).bind('cancel.' + helper.getClass(models.name) + ' ' + 'apply.' + helper.getClass(models.name), function () {
|
||
$overlay.removeClass(overlayActiveClass).hide();
|
||
$parent.removeClass(wrapperActiveClass).hide();
|
||
});
|
||
}
|
||
|
||
var generateDateRange = function generateDateRange() {
|
||
if (!local.current[0] || !local.current[1]) {
|
||
return false;
|
||
}
|
||
|
||
var firstSelectDate = local.current[0].format('YYYY-MM-DD');
|
||
var lastSelectDate = local.current[1].format('YYYY-MM-DD');
|
||
var firstDate = moment(Math.max(local.current[0].valueOf(), local.dateManager.date.clone().startOf('month').valueOf()));
|
||
var lastDate = moment(Math.min(local.current[1].valueOf(), local.dateManager.date.clone().endOf('month').valueOf()));
|
||
var firstDateIsUndered = firstDate.format('YYYY-MM-DD') !== firstSelectDate;
|
||
var lastDateIsOvered = lastDate.format('YYYY-MM-DD') !== lastSelectDate;
|
||
|
||
if (firstDateIsUndered === false) {
|
||
firstDate.add(1, 'days');
|
||
}
|
||
|
||
if (lastDateIsOvered === false) {
|
||
lastDate.add(-1, 'days');
|
||
}
|
||
|
||
var firstDateFixed = firstDate.format('YYYY-MM-DD');
|
||
var lastDateFixed = lastDate.format('YYYY-MM-DD');
|
||
|
||
for (; firstDate.format('YYYY-MM-DD') <= lastDate.format('YYYY-MM-DD'); firstDate.add(1, 'days')) {
|
||
var date = firstDate.format('YYYY-MM-DD');
|
||
var isRange = true;
|
||
var $target = local.calendar.find(helper.format('.{0}[data-date="{1}"]', helper.getSubClass('unit'), date)).addClass(rangeClass);
|
||
|
||
if (date === firstDateFixed) {
|
||
$target.addClass(rangeFirstClass);
|
||
}
|
||
|
||
if (date === lastDateFixed) {
|
||
$target.addClass(rangeLastClass);
|
||
}
|
||
}
|
||
};
|
||
|
||
var existsBetweenRange = function existsBetweenRange(startDate, endDate, targetDate) {
|
||
if (targetDate) {
|
||
if (startDate.diff(targetDate) < 0 && endDate.diff(targetDate) > 0) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
var validDate = function validDate(date) {
|
||
if (context.settings.disabledDates.indexOf(date) !== -1) {
|
||
return false;
|
||
}
|
||
|
||
if (date.diff(context.settings.maxDate) >= 0) {
|
||
return false;
|
||
}
|
||
|
||
if (date.diff(context.settings.minDate) <= 0) {
|
||
return false;
|
||
}
|
||
|
||
for (var idx in context.settings.disabledRanges) {
|
||
var rangeDate = context.settings.disabledRanges[idx];
|
||
var startRangeDate = moment(rangeDate[0]);
|
||
var endRangeDate = moment(rangeDate[1]);
|
||
|
||
if (existsBetweenRange(startRangeDate, endRangeDate, date)) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
var weekday = date.weekday();
|
||
if (context.settings.disabledWeekdays.indexOf(weekday) !== -1) {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
var validDateArea = function validDateArea(startDate, endDate) {
|
||
var date = void 0;
|
||
|
||
for (var idx in context.settings.disabledDates) {
|
||
date = moment(context.settings.disabledDates[idx]);
|
||
if (existsBetweenRange(startDate, endDate, date)) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (existsBetweenRange(startDate, endDate, context.settings.maxDate)) {
|
||
return false;
|
||
}
|
||
|
||
if (existsBetweenRange(startDate, endDate, context.settings.minDate)) {
|
||
return false;
|
||
}
|
||
|
||
for (var _idx in context.settings.disabledRanges) {
|
||
var rangeDate = context.settings.disabledRanges[_idx];
|
||
var startRangeDate = moment(rangeDate[0]);
|
||
var endRangeDate = moment(rangeDate[1]);
|
||
|
||
if (existsBetweenRange(startDate, endDate, startRangeDate) || existsBetweenRange(startDate, endDate, endRangeDate)) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
var startWeekday = startDate.weekday();
|
||
var endWeekday = endDate.weekday();
|
||
var tmp = void 0;
|
||
|
||
if (startWeekday > endWeekday) {
|
||
tmp = startWeekday;
|
||
startWeekday = endWeekday;
|
||
endWeekday = tmp;
|
||
}
|
||
|
||
for (var _idx2 = 0, index = 0; _idx2 < context.settings.disabledWeekdays.length && index < 7; _idx2++) {
|
||
index++;
|
||
var _week = context.settings.disabledWeekdays[_idx2];
|
||
|
||
if (_week >= startWeekday && _week <= endWeekday) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
local.renderer = function () {
|
||
local.calendar.appendTo($parent.empty());
|
||
local.calendar.find('.' + classNames.top + '-year').text(local.dateManager.year);
|
||
local.calendar.find('.' + classNames.top + '-month').text(context.settings.monthsLong[local.dateManager.month - 1]);
|
||
local.calendar.find(helper.format('.{0}-prev .{0}-value', classNames.top)).text(context.settings.months[local.dateManager.prevMonth - 1].toUpperCase());
|
||
local.calendar.find(helper.format('.{0}-next .{0}-value', classNames.top)).text(context.settings.months[local.dateManager.nextMonth - 1].toUpperCase());
|
||
|
||
if (context.settings.buttons === true && $calendarButton) {
|
||
var $super = $this;
|
||
$calendarButton.find('.' + classNames.button).bind('click', function (event) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
var $this = $(this);
|
||
|
||
if ($this.hasClass(classNames.button + '-apply')) {
|
||
$this.trigger('apply.' + models.name, local);
|
||
var value = '';
|
||
if (context.settings.toggle === true) {
|
||
value = local.storage.activeDates.join(', ');
|
||
} else if (context.settings.multiple === true) {
|
||
var dateValues = [];
|
||
|
||
if (local.current[0] !== null) {
|
||
dateValues.push(local.current[0].format(context.settings.format));
|
||
}
|
||
|
||
if (local.current[1] !== null) {
|
||
dateValues.push(local.current[1].format(context.settings.format));
|
||
}
|
||
|
||
value = dateValues.join(' ~ ');
|
||
} else {
|
||
value = local.current[0] === null ? '' : moment(local.current[0]).format(context.settings.format);
|
||
}
|
||
|
||
if (local.input === true) {
|
||
$super.val(value).triggerHandler('change');
|
||
}
|
||
|
||
if (typeof context.settings.apply === 'function') {
|
||
context.settings.apply.call(local.calendar, local.current, local);
|
||
}
|
||
$parent.triggerHandler('apply.' + helper.getClass(models.name));
|
||
} else {
|
||
$parent.triggerHandler('cancel.' + helper.getClass(models.name));
|
||
}
|
||
});
|
||
}
|
||
|
||
var $calendarBody = local.calendar.find('.' + classNames.body).empty();
|
||
var firstDate = DateManager.Convert(local.dateManager.year, local.dateManager.month, local.dateManager.firstDay);
|
||
var lastDate = DateManager.Convert(local.dateManager.year, local.dateManager.month, local.dateManager.lastDay);
|
||
var firstWeekday = firstDate.weekday() - context.settings.week;
|
||
var lastWeekday = lastDate.weekday() - context.settings.week;
|
||
|
||
if (firstWeekday < 0) {
|
||
firstWeekday += context.settings.weeks.length;
|
||
}
|
||
|
||
var $unitList = [],
|
||
currentFormat = [local.current[0] === null ? null : local.current[0].format('YYYY-MM-DD'), local.current[1] === null ? null : local.current[1].format('YYYY-MM-DD')],
|
||
minDate = context.settings.minDate === null ? null : moment(context.settings.minDate),
|
||
maxDate = context.settings.maxDate === null ? null : moment(context.settings.maxDate);
|
||
|
||
for (var _i = 0; _i < firstWeekday; _i++) {
|
||
var $unit = $(helper.format('<div class="{0} {0}-{1}"></div>', helper.getSubClass('unit'), global.languages.weeks.en[_i].toLowerCase()));
|
||
$unitList.push($unit);
|
||
}
|
||
|
||
var _loop = function _loop(_i2) {
|
||
var iDate = DateManager.Convert(local.dateManager.year, local.dateManager.month, _i2);
|
||
var iDateFormat = iDate.format('YYYY-MM-DD');
|
||
var $unit = $(helper.format('<div class="{0} {0}-date {0}-{3}" data-date="{1}"><a href="#">{2}</a></div>', helper.getSubClass('unit'), iDate.format('YYYY-MM-DD'), _i2, global.languages.weeks.en[iDate.weekday()].toLowerCase()));
|
||
|
||
if (context.settings.enabledDates.length > 0) {
|
||
if ($.inArray(iDateFormat, context.settings.enabledDates) === -1) {
|
||
$unit.addClass(helper.getSubClass('unitDisabled'));
|
||
}
|
||
} else if (context.settings.disabledWeekdays.length > 0 && $.inArray(iDate.weekday(), context.settings.disabledWeekdays) !== -1) {
|
||
$unit.addClass(helper.getSubClass('unitDisabled')).addClass(helper.getSubClass('unitDisabledWeekdays'));
|
||
} else if (minDate !== null && minDate.diff(iDate) > 0 || maxDate !== null && maxDate.diff(iDate) < 0) {
|
||
$unit.addClass(helper.getSubClass('unitDisabled')).addClass(helper.getSubClass('unitDisabledRange'));
|
||
} else if ($.inArray(iDateFormat, context.settings.disabledDates) !== -1) {
|
||
$unit.addClass(helper.getSubClass('unitDisabled'));
|
||
} else if (context.settings.disabledRanges.length > 0) {
|
||
var disabledRangesLength = context.settings.disabledRanges.length;
|
||
for (var j = 0; j < disabledRangesLength; j++) {
|
||
var disabledRange = context.settings.disabledRanges[j];
|
||
var disabledRangeLength = disabledRange.length;
|
||
|
||
if (iDate.diff(moment(disabledRange[0])) >= 0 && iDate.diff(moment(disabledRange[1])) <= 0) {
|
||
$unit.addClass(helper.getSubClass('unitDisabled')).addClass(helper.getSubClass('unitDisabledRange')).addClass(helper.getSubClass('unitDisabledMultipleRange'));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (context.settings.schedules.length > 0 && _typeof(context.settings.scheduleOptions) === 'object' && _typeof(context.settings.scheduleOptions.colors) === 'object') {
|
||
var currentSchedules = context.settings.schedules.filter(function (schedule) {
|
||
return schedule.date === iDateFormat;
|
||
});
|
||
|
||
var nameOfSchedules = $.unique(currentSchedules.map(function (schedule, index) {
|
||
return schedule.name;
|
||
}).sort());
|
||
|
||
if (nameOfSchedules.length > 0) {
|
||
//$unit.data('schedules', currentSchedules);
|
||
var $schedulePinContainer = $(context.global.calendarScheduleContainerHtml);
|
||
$schedulePinContainer.appendTo($unit);
|
||
nameOfSchedules.map(function (name, index) {
|
||
if (context.settings.scheduleOptions.colors[name]) {
|
||
var color = context.settings.scheduleOptions.colors[name];
|
||
var $schedulePin = $(helper.format(context.global.calendarSchedulePinHtml, name, color));
|
||
$schedulePin.appendTo($schedulePinContainer);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
if (context.settings.toggle === true) {
|
||
if ($.inArray(iDateFormat, local.storage.activeDates) !== -1 && local.storage.activeDates.length > 0) {
|
||
$unit.addClass(toggleActiveClass);
|
||
} else {
|
||
$unit.addClass(toggleInactiveClass);
|
||
}
|
||
} else if ($unit.hasClass(helper.getSubClass('unitDisabled')) === false) {
|
||
if (context.settings.multiple === true) {
|
||
if (currentFormat[0] && iDateFormat === currentFormat[0]) {
|
||
$unit.addClass(activeClass).addClass(activePositionClasses[0]);
|
||
}
|
||
|
||
if (currentFormat[1] && iDateFormat === currentFormat[1]) {
|
||
$unit.addClass(activeClass).addClass(activePositionClasses[1]);
|
||
}
|
||
} else {
|
||
if (currentFormat[0] && iDateFormat === currentFormat[0] && $.inArray(currentFormat[0], context.settings.disabledDates) === -1 && (context.settings.enabledDates.length < 1 || $.inArray(currentFormat[0], context.settings.enabledDates) !== -1)) {
|
||
$unit.addClass(activeClass).addClass(activePositionClasses[0]);
|
||
}
|
||
}
|
||
}
|
||
|
||
$unitList.push($unit);
|
||
var $super = $this;
|
||
|
||
$unit.bind('click', function (event) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
|
||
var $this = $(this);
|
||
var date = $this.data('date');
|
||
var position = 0;
|
||
var preventSelect = false;
|
||
|
||
if ($this.hasClass(helper.getSubClass('unitDisabled'))) {
|
||
preventSelect = true;
|
||
} else {
|
||
if (local.input === true && context.settings.multiple === false && context.settings.buttons === false) {
|
||
$super.val(moment(date).format(context.settings.format));
|
||
$parent.triggerHandler('apply.' + helper.getClass(models.name));
|
||
} else {
|
||
if (local.initialize !== null && local.initialize.format('YYYY-MM-DD') === date && context.settings.toggle === false) {} else {
|
||
if (context.settings.toggle === true) {
|
||
var match = local.storage.activeDates.filter(function (e, i) {
|
||
return e === date;
|
||
});
|
||
local.current[position] = moment(date);
|
||
|
||
if (match.length < 1) {
|
||
local.storage.activeDates.push(date);
|
||
$this.addClass(toggleActiveClass).removeClass(toggleInactiveClass);
|
||
} else {
|
||
var index = 0;
|
||
for (var idx = 0; idx < local.storage.activeDates.length; idx++) {
|
||
var targetDate = local.storage.activeDates[idx];
|
||
|
||
if (date === targetDate) {
|
||
index = idx;
|
||
break;
|
||
}
|
||
}
|
||
local.storage.activeDates.splice(index, 1);
|
||
$this.removeClass(toggleActiveClass).addClass(toggleInactiveClass);
|
||
}
|
||
} else if ($this.hasClass(activeClass) === true && context.settings.pickWeeks === false) {
|
||
if (context.settings.multiple === true) {
|
||
if ($this.hasClass(activePositionClasses[0])) {
|
||
position = 0;
|
||
} else if (activePositionClasses[1]) {
|
||
position = 1;
|
||
}
|
||
}
|
||
$this.removeClass(activeClass).removeClass(activePositionClasses[position]);
|
||
local.current[position] = null;
|
||
} else {
|
||
if (context.settings.pickWeeks === true) {
|
||
if ($this.hasClass(activeClass) === true || $this.hasClass(rangeClass) === true) {
|
||
for (var _j = 0; _j < 2; _j++) {
|
||
local.calendar.find('.' + activeClass + '.' + activePositionClasses[_j]).removeClass(activeClass).removeClass(activePositionClasses[_j]);
|
||
}
|
||
|
||
local.current[0] = null;
|
||
local.current[1] = null;
|
||
} else {
|
||
local.current[0] = moment(date).startOf('week').add(context.settings.week, 'days');
|
||
local.current[1] = moment(date).endOf('week').add(context.settings.week, 'days');
|
||
|
||
for (var _j2 = 0; _j2 < 2; _j2++) {
|
||
local.calendar.find('.' + activeClass + '.' + activePositionClasses[_j2]).removeClass(activeClass).removeClass(activePositionClasses[_j2]);
|
||
local.calendar.find(helper.format('.{0}[data-date="{1}"]', helper.getSubClass('unit'), local.current[_j2].format('YYYY-MM-DD'))).addClass(activeClass).addClass(activePositionClasses[_j2]);
|
||
}
|
||
}
|
||
} else {
|
||
if (context.settings.multiple === true) {
|
||
if (local.current[0] === null) {
|
||
position = 0;
|
||
} else if (local.current[1] === null) {
|
||
position = 1;
|
||
} else {
|
||
position = 0;
|
||
local.current[1] = null;
|
||
local.calendar.find('.' + activeClass + '.' + activePositionClasses[1]).removeClass(activeClass).removeClass(activePositionClasses[1]);
|
||
}
|
||
}
|
||
|
||
local.calendar.find('.' + activeClass + '.' + activePositionClasses[position]).removeClass(activeClass).removeClass(activePositionClasses[position]);
|
||
$this.addClass(activeClass).addClass(activePositionClasses[position]);
|
||
local.current[position] = moment(date);
|
||
}
|
||
|
||
if (local.current[0] && local.current[1]) {
|
||
if (local.current[0].diff(local.current[1]) > 0) {
|
||
var tmp = local.current[0];
|
||
local.current[0] = local.current[1];
|
||
local.current[1] = tmp;
|
||
tmp = null;
|
||
|
||
local.calendar.find('.' + activeClass).each(function () {
|
||
var $this = $(this);
|
||
for (var _idx3 in activePositionClasses) {
|
||
var className = activePositionClasses[_idx3];
|
||
$this.toggleClass(className);
|
||
}
|
||
});
|
||
}
|
||
|
||
if (validDateArea(local.current[0], local.current[1]) === false && context.settings.selectOver === false) {
|
||
local.current[0] = null;
|
||
local.current[1] = null;
|
||
local.calendar.find('.' + activeClass).removeClass(activeClass).removeClass(activePositionClasses[0]).removeClass(activePositionClasses[1]);
|
||
}
|
||
|
||
if (local.input === true && context.settings.buttons === false) {
|
||
var dateValues = [];
|
||
|
||
if (local.current[0] !== null) {
|
||
dateValues.push(local.current[0].format(context.settings.format));
|
||
}
|
||
|
||
if (local.current[1] !== null) {
|
||
dateValues.push(local.current[1].format(context.settings.format));
|
||
}
|
||
|
||
$this.val(dateValues.join(', '));
|
||
$parent.trigger('apply.' + helper.getClass(models.name));
|
||
}
|
||
}
|
||
}
|
||
|
||
if (context.settings.multiple === true) {
|
||
local.calendar.find('.' + rangeClass).removeClass(rangeClass).removeClass(rangeFirstClass).removeClass(rangeLastClass);
|
||
generateDateRange.call();
|
||
}
|
||
|
||
if (context.settings.schedules.length > 0) {
|
||
local.storage.schedules = context.settings.schedules.filter(function (event) {
|
||
return event.date === date;
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
var classifyDate = function classifyDate(date) {
|
||
local.date.all.push(date);
|
||
if (validDate(moment(date))) {
|
||
local.date.enabled.push(date);
|
||
} else {
|
||
local.date.disabled.push(date);
|
||
}
|
||
};
|
||
|
||
if (local.current[0]) {
|
||
if (local.current[1]) {
|
||
var startDate = local.current[0];
|
||
var _date = startDate.clone();
|
||
|
||
for (; _date.format('YYYY-MM-DD') <= local.current[1].format('YYYY-MM-DD'); _date.add('1', 'days')) {
|
||
classifyDate(_date.clone());
|
||
}
|
||
} else {
|
||
var _date2 = local.current[0];
|
||
classifyDate(_date2.clone());
|
||
}
|
||
}
|
||
|
||
if (preventSelect === false) {
|
||
local.initialize = null;
|
||
|
||
if (typeof context.settings.select === 'function') {
|
||
context.settings.select.call($this, local.current, local);
|
||
}
|
||
}
|
||
|
||
if (typeof context.settings.click === 'function') {
|
||
context.settings.click.call($this, event, local);
|
||
}
|
||
});
|
||
};
|
||
|
||
for (var _i2 = local.dateManager.firstDay; _i2 <= local.dateManager.lastDay; _i2++) {
|
||
_loop(_i2);
|
||
}
|
||
|
||
for (var _i3 = lastWeekday + 1; $unitList.length < context.settings.weeks.length * 5; _i3++) {
|
||
if (_i3 < 0) {
|
||
_i3 = global.languages.weeks.en.length - _i3;
|
||
}
|
||
var _$unit = $(helper.format('<div class="{0} {0}-{1}"></div>', helper.getSubClass('unit'), global.languages.weeks.en[_i3 % global.languages.weeks.en.length].toLowerCase()));
|
||
$unitList.push(_$unit);
|
||
}
|
||
|
||
var $row = null;
|
||
for (var _i4 = 0; _i4 < $unitList.length; _i4++) {
|
||
var element = $unitList[_i4];
|
||
if (_i4 % context.settings.weeks.length == 0 || _i4 + 1 >= $unitList.length) {
|
||
if ($row !== null) {
|
||
$row.appendTo($calendarBody);
|
||
}
|
||
|
||
if (_i4 + 1 < $unitList.length) {
|
||
$row = $(helper.format('<div class="{0}"></div>', helper.getSubClass('row')));
|
||
}
|
||
}
|
||
$row.append(element);
|
||
}
|
||
|
||
local.calendar.find('.' + classNames.top + '-nav').bind('click', function (event) {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
var $this = $(this);
|
||
var type = 'unkown';
|
||
|
||
if ($this.hasClass(classNames.top + '-prev')) {
|
||
type = 'prev';
|
||
local.dateManager = new DateManager(local.dateManager.date.clone().add(-1, 'months'));
|
||
} else if ($this.hasClass(classNames.top + '-next')) {
|
||
type = 'next';
|
||
local.dateManager = new DateManager(local.dateManager.date.clone().add(1, 'months'));
|
||
}
|
||
|
||
if (typeof context.settings.page === 'function') {
|
||
context.settings.page.call($this, {
|
||
type: type,
|
||
year: local.dateManager.year,
|
||
month: local.dateManager.month,
|
||
day: local.dateManager.day
|
||
}, local);
|
||
}
|
||
|
||
if (typeof context.settings[type] === 'function') {
|
||
context.settings[type].call($this, {
|
||
type: type,
|
||
year: local.dateManager.year,
|
||
month: local.dateManager.month,
|
||
day: local.dateManager.day
|
||
}, local);
|
||
}
|
||
|
||
local.renderer.call();
|
||
});
|
||
|
||
if (context.settings.multiple === true) {
|
||
local.calendar.find('.' + rangeClass).removeClass(rangeClass).removeClass(rangeFirstClass).removeClass(rangeLastClass);
|
||
generateDateRange.call();
|
||
}
|
||
};
|
||
|
||
local.renderer.call();
|
||
$this[0][models.name] = local;
|
||
|
||
if (typeof context.settings.init === 'function') {
|
||
context.settings.init.call($this, local);
|
||
}
|
||
});
|
||
};
|
||
});
|
||
//# sourceMappingURL=init.js.map
|
||
;
|
||
|
||
|
||
define('methods/setting',['../component/global', '../configures/i18n', 'jquery'], function (global, language, $) {
|
||
return function (options) {
|
||
var settings = $.extend({
|
||
language: global.language,
|
||
languages: {},
|
||
week: null,
|
||
format: null
|
||
}, options);
|
||
var monthsCount = 12;
|
||
var weeksCount = 7;
|
||
|
||
global.language = settings.language;
|
||
|
||
if (Object.keys(settings.languages).length > 0) {
|
||
var _loop = function _loop(_language) {
|
||
var languageSetting = settings.languages[_language];
|
||
|
||
if (typeof _language !== 'string') {
|
||
console.error('global configuration is failed.\nMessage: language key is not a string type.', _language);
|
||
}
|
||
|
||
if (!languageSetting.weeks) {
|
||
console.warn('Warning: `weeks` option of `' + _language + '` language is missing.');
|
||
return 'break';
|
||
}
|
||
|
||
if (!languageSetting.monthsLong) {
|
||
console.warn('Warning: `monthsLong` option of `' + _language + '` language is missing.');
|
||
return 'break';
|
||
}
|
||
|
||
if (!languageSetting.months) {
|
||
console.warn('Warning: `months` option of `' + _language + '` language is missing.');
|
||
return 'break';
|
||
}
|
||
|
||
if (!languageSetting.controls) {
|
||
console.warn('Warning: `controls` option of `' + _language + '` language is missing.');
|
||
return 'break';
|
||
}
|
||
|
||
if (languageSetting.weeks) {
|
||
if (languageSetting.weeks.length < weeksCount) {
|
||
console.error('`weeks` must have least ' + weeksCount + ' items.');
|
||
return 'break';
|
||
} else if (languageSetting.weeks.length !== weeksCount) {
|
||
console.warn('`weeks` option over ' + weeksCount + ' items. We recommend to give ' + weeksCount + ' items.');
|
||
}
|
||
}
|
||
|
||
if (languageSetting.monthsLong) {
|
||
if (languageSetting.monthsLong.length < monthsCount) {
|
||
console.error('`monthsLong` must have least ' + monthsCount + ' items.');
|
||
return 'break';
|
||
} else if (languageSetting.monthsLong.length !== monthsCount) {
|
||
console.warn('`monthsLong` option over ' + monthsCount + ' items. We recommend to give ' + monthsCount + ' items.');
|
||
}
|
||
}
|
||
|
||
if (languageSetting.months) {
|
||
if (languageSetting.months.length < monthsCount) {
|
||
console.error('`months` must have least ' + monthsCount + ' items.');
|
||
return 'break';
|
||
} else if (languageSetting.months.length !== monthsCount) {
|
||
console.warn('`months` option over ' + monthsCount + ' items. We recommend to give ' + monthsCount + ' items.');
|
||
}
|
||
}
|
||
|
||
if (languageSetting.controls) {
|
||
if (!languageSetting.controls.ok) {
|
||
console.error('`controls.ok` value is missing in your language setting');
|
||
return 'break';
|
||
}
|
||
|
||
if (!languageSetting.controls.cancel) {
|
||
console.error('`controls.cancel` value is missing in your language setting');
|
||
return 'break';
|
||
}
|
||
}
|
||
|
||
if (global.languages.supports.indexOf(_language) === -1) {
|
||
global.languages.supports.push(_language);
|
||
}
|
||
|
||
['weeks', 'monthsLong', 'months', 'controls'].map(function (key) {
|
||
if (global.languages[key][_language]) {
|
||
console.warn('`' + _language + '` language is already given however it will be overwriten.');
|
||
}
|
||
global.languages[key][_language] = languageSetting[key] || global.languages[key][_language.defaultLanguage];
|
||
});
|
||
};
|
||
|
||
for (var _language in settings.languages) {
|
||
var _ret = _loop(_language);
|
||
|
||
if (_ret === 'break') break;
|
||
}
|
||
}
|
||
|
||
if (settings.week) {
|
||
if (typeof settings.week === 'number') {
|
||
global.week = settings.week;
|
||
} else {
|
||
console.error('global configuration is failed.\nMessage: You must give `week` option as number type.');
|
||
}
|
||
}
|
||
|
||
if (settings.format) {
|
||
if (typeof settings.format === 'string') {
|
||
global.format = settings.format;
|
||
} else {
|
||
console.error('global configuration is failed.\nMessage: You must give `format` option as string type.');
|
||
}
|
||
}
|
||
};
|
||
});
|
||
//# sourceMappingURL=setting.js.map
|
||
;
|
||
|
||
|
||
define('methods/select',['../component/helper', 'jquery'], function (helper, $) {
|
||
return function (day) {
|
||
this.each(function () {
|
||
var local = this.local;
|
||
var dateManager = local.dateManager;
|
||
var date = helper.format('{0}-{1}-{2}', dateManager.year, dateManager.month, day);
|
||
$(this).find(helper.format('.{0}[data-date="{1}"]', helper.getSubClass('unit'), date)).triggerHandler('click');
|
||
});
|
||
};
|
||
});
|
||
//# sourceMappingURL=select.js.map
|
||
;
|
||
|
||
|
||
define('methods/set',['jquery', 'moment', '../manager/index', '../component/models'], function ($, moment, DateManager, models) {
|
||
return function (date) {
|
||
if (date) {
|
||
var dateSplit = date.split('~').map(function (element) {
|
||
var format = $.trim(element);
|
||
return !format ? null : format;
|
||
});
|
||
|
||
this.each(function () {
|
||
var $this = $(this);
|
||
var local = $this[0][models.name];
|
||
var context = local.context;
|
||
|
||
var dateArray = [!dateSplit[0] ? null : moment(dateSplit[0], context.settings.format), !dateSplit[1] ? null : moment(dateSplit[1], context.settings.format)];
|
||
local.dateManager = new DateManager(dateArray[0]);
|
||
|
||
if (context.settings.pickWeeks === true) {
|
||
if (dateArray[0]) {
|
||
var _date = dateArray[0];
|
||
dateArray[0] = _date.clone().startOf('week');
|
||
dateArray[1] = _date.clone().endOf('week');
|
||
}
|
||
}
|
||
|
||
if (context.settings.toggle === true) {
|
||
local.storage.activeDates = dateSplit;
|
||
} else {
|
||
local.current = dateArray;
|
||
}
|
||
local.renderer.call();
|
||
});
|
||
}
|
||
};
|
||
});
|
||
//# sourceMappingURL=set.js.map
|
||
;
|
||
|
||
|
||
define('methods/index',['./init', './configure', './setting', './select', './set'], function (methodInit, methodConfigure, methodSetting, methodSelect, methodSet) {
|
||
return {
|
||
init: methodInit,
|
||
configure: methodConfigure,
|
||
setting: methodSetting,
|
||
select: methodSelect,
|
||
set: methodSet
|
||
};
|
||
});
|
||
//# sourceMappingURL=index.js.map
|
||
;
|
||
|
||
|
||
define('component/polyfills',[], function () {
|
||
if (!Array.prototype.filter) {
|
||
Array.prototype.filter = function (func) {
|
||
'use strict';
|
||
|
||
if (this === null) {
|
||
throw new TypeError();
|
||
}
|
||
|
||
var t = Object(this);
|
||
var len = t.length >>> 0;
|
||
|
||
if (typeof func !== 'function') {
|
||
return [];
|
||
}
|
||
|
||
var res = [];
|
||
var thisp = arguments[1];
|
||
for (var i = 0; i < len; i++) {
|
||
if (i in t) {
|
||
var val = t[i];
|
||
if (func.call(thisp, val, i, t)) {
|
||
res.push(val);
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
}
|
||
});
|
||
//# sourceMappingURL=polyfills.js.map
|
||
;
|
||
|
||
|
||
define('core',['./methods/index', './component/models', './component/polyfills'], function (methods, models) {
|
||
'use strict';
|
||
|
||
window[models.name] = {
|
||
version: models.version
|
||
};
|
||
|
||
var Component = methods;
|
||
return Component;
|
||
});
|
||
//# sourceMappingURL=core.js.map
|
||
;
|
||
|
||
|
||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
||
|
||
define('main',['core', 'component/models'], function (component, models) {
|
||
'use strict';
|
||
|
||
var pignoseCalendar = function pignoseCalendar(element, options) {
|
||
if (typeof component[options] !== 'undefined') {
|
||
return component[options].apply(element, Array.prototype.slice.call(arguments, 2));
|
||
} else if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object' || !options) {
|
||
return component.init.apply(element, Array.prototype.slice.call(arguments, 1));
|
||
} else {
|
||
console.error('Argument error are occured.');
|
||
}
|
||
};
|
||
|
||
pignoseCalendar.component = {};
|
||
for (var idx in models) {
|
||
pignoseCalendar.component[idx] = models[idx];
|
||
}
|
||
|
||
return pignoseCalendar;
|
||
});
|
||
//# sourceMappingURL=main.js.map
|
||
;
|
||
|
||
|
||
var main = require('main');
|
||
var models = require('component/models');
|
||
var $ = require('jquery');
|
||
|
||
var root = window ? window : undefined || {};
|
||
|
||
root.moment = require('moment');
|
||
|
||
$.fn[models.name] = function (options) {
|
||
return main.apply(main, [this, options].concat(Array.prototype.splice.call(arguments, 1)));
|
||
};
|
||
|
||
for (var key in models) {
|
||
$.fn[models.name][key] = models[key];
|
||
}
|
||
//# sourceMappingURL=jquery.js.map
|
||
;
|
||
define("plugins/jquery.js", function(){});
|
||
|
||
|
||
|
||
|
||
return ;
|
||
|
||
}));
|