@progress/kendo-ui
Version:
This package is part of the [Kendo UI for jQuery](http://www.telerik.com/kendo-ui) suite.
7,012 lines • 228 kB
JavaScript
let _progress_kendo_licensing = require("@progress/kendo-licensing");
//#region ../src/utils/mediaquery.js
let breakpoints;
const EVENT = "change";
const defaultBreakpoints = {
small: "(max-width: 500px)",
medium: "(min-width: 500.1px) and (max-width: 768px)",
large: "(min-width: 768.1px)"
};
function createMediaQuery(query) {
let mediaQueryList = window.matchMedia(query);
let onEnterCallbacks = [];
let onLeaveCallbacks = [];
let onChangeHandlers = [];
let kendoMediaQuery = { mediaQueryList };
const onChangeHandler = (ev) => {
onChangeHandlers.forEach((cb) => cb(ev));
if (ev.matches) onEnterCallbacks.forEach((cb) => cb(ev));
else onLeaveCallbacks.forEach((cb) => cb(ev));
};
mediaQueryList.addEventListener(EVENT, onChangeHandler);
const onChange = (cb) => {
onChangeHandlers.push(cb);
return kendoMediaQuery;
};
const onEnter = (cb) => {
onEnterCallbacks.push(cb);
if (mediaQueryList.matches) {
const media = mediaQueryList.media;
cb(new MediaQueryListEvent(EVENT, {
media,
matches: true
}));
}
return kendoMediaQuery;
};
const onLeave = (cb) => {
onLeaveCallbacks.push(cb);
return kendoMediaQuery;
};
const destroy = () => {
if (mediaQueryList) mediaQueryList.removeEventListener(EVENT, onChangeHandler);
onEnterCallbacks = null;
onLeaveCallbacks = null;
onChangeHandlers = null;
mediaQueryList = null;
kendoMediaQuery = null;
};
kendoMediaQuery.onChange = onChange;
kendoMediaQuery.onEnter = onEnter;
kendoMediaQuery.onLeave = onLeave;
kendoMediaQuery.destroy = destroy;
return kendoMediaQuery;
}
function mediaQuery(query) {
if (!query) return;
breakpoints = breakpoints || Object.assign({}, defaultBreakpoints, kendo.defaults.breakpoints);
if (query in breakpoints) query = breakpoints[query];
return createMediaQuery(query);
}
//#endregion
//#region ../src/utils/convert-class.js
function fromESClass(ESClass) {
class ExtendedClass extends ESClass {
static extend(proto) {
const subclass = class extends ExtendedClass {
constructor() {
super();
if (proto && proto.init) proto.init.apply(this, arguments);
}
};
Object.assign(subclass.prototype, proto);
addInstanceGetter(subclass.prototype);
subclass.fn = subclass.prototype;
return subclass;
}
}
addInstanceGetter(ExtendedClass.prototype);
ExtendedClass.fn = ExtendedClass.prototype;
return ExtendedClass;
}
function addInstanceGetter(proto) {
Object.defineProperty(proto, "_instance", { get: function() {
return this;
} });
}
//#endregion
//#region ../src/core/models/date-utils.ts
/**
* Date utility type definitions
*/
/**
* Date field mapping for format parsing
*/
const DATE_FIELD_MAP = {
"G": "era",
"y": "year",
"q": "quarter",
"Q": "quarter",
"M": "month",
"L": "month",
"d": "day",
"E": "weekday",
"c": "weekday",
"e": "weekday",
"h": "hour",
"H": "hour",
"k": "hour",
"K": "hour",
"m": "minute",
"s": "second",
"a": "dayperiod",
"t": "dayperiod",
"x": "zone",
"X": "zone",
"z": "zone",
"Z": "zone"
};
/**
* Name types for date formatting
*/
const NAME_TYPES = {
month: {
type: "months",
minLength: 3,
standAlone: "L"
},
quarter: {
type: "quarters",
minLength: 3,
standAlone: "q"
},
weekday: {
type: "days",
minLength: {
E: 0,
c: 3,
e: 3
},
standAlone: "c"
},
dayperiod: {
type: "dayPeriods",
minLength: 0
},
era: {
type: "eras",
minLength: 0
}
};
//#endregion
//#region ../src/core/services/support.service.ts
const UNDEFINED$2 = "undefined";
/**
* Test a value against a set of regex patterns
*/
function testRx(agent, rxs, dflt) {
for (const rx in rxs) if (rxs.hasOwnProperty(rx) && rxs[rx].test(agent)) return rx;
return dflt !== void 0 ? dflt : agent;
}
/**
* Support detection service for browser, OS, and feature detection
*/
var SupportService = class {
constructor() {
this._scrollbar = void 0;
this.scrollbar = this.scrollbar.bind(this);
this.isRtl = this.isRtl.bind(this);
this.detectOS = this.detectOS.bind(this);
this.detectBrowser = this.detectBrowser.bind(this);
this.detectClipboardAccess = this.detectClipboardAccess.bind(this);
this.zoomLevel = this.zoomLevel.bind(this);
this.delayedClick = this.delayedClick.bind(this);
this.initialize();
}
initialize() {
const win = window;
const doc = document;
const nav = navigator;
const table = doc.createElement("table");
try {
table.innerHTML = "<tr><td></td></tr>";
this.tbodyInnerHtml = true;
} catch (e) {
this.tbodyInnerHtml = false;
}
this.touch = "ontouchstart" in win;
const docStyle = doc.documentElement.style;
const elementProto = "HTMLElement" in win ? HTMLElement.prototype : [];
this.transforms = this.transitions = {
css: "",
prefix: "",
event: "transitionend"
};
this.hasHW3D = "WebKitCSSMatrix" in win && "m11" in new win.WebKitCSSMatrix() || "MozPerspective" in docStyle || "msPerspective" in docStyle;
this.cssFlexbox = "flexWrap" in docStyle || "WebkitFlexWrap" in docStyle || "msFlexWrap" in docStyle;
this.devicePixelRatio = win.devicePixelRatio === void 0 ? 1 : win.devicePixelRatio;
try {
this.screenWidth = win.outerWidth || win.screen ? win.screen.availWidth : win.innerWidth;
this.screenHeight = win.outerHeight || win.screen ? win.screen.availHeight : win.innerHeight;
} catch (e) {
this.screenWidth = win.screen.availWidth;
this.screenHeight = win.screen.availHeight;
}
let mobileOS = this.detectOS(nav.userAgent);
this.mobileOS = mobileOS;
this.wpDevicePixelRatio = mobileOS && mobileOS.wp ? screen.width / 320 : 0;
this.hasNativeScrolling = false;
if (mobileOS && (mobileOS.ios || mobileOS.android && parseInt(mobileOS.majorVersion) > 2 || mobileOS.wp)) this.hasNativeScrolling = mobileOS;
this.mouseAndTouchPresent = this.touch && !(mobileOS && (mobileOS.ios || mobileOS.android));
this.browser = this.detectBrowser(nav.userAgent);
if (!mobileOS && this.touch && this.browser.safari) mobileOS = this.mobileOS = {
ios: true,
tablet: "tablet",
device: "ipad",
majorVersion: "13",
minorVersion: "0",
flatVersion: "1300",
cordova: false,
appMode: false,
name: "ios",
browser: "mobilesafari"
};
this.clipboard = this.detectClipboardAccess();
this.eventCapture = !!doc.documentElement.addEventListener;
const input = doc.createElement("input");
this.placeholder = "placeholder" in input;
this.propertyChangeEvent = "onpropertychange" in input;
this.input = this.detectInputTypes(input);
input.style.cssText = "float:left;";
this.cssFloat = !!input.style.cssFloat;
this.stableSort = this.detectStableSort();
this.matchesSelector = elementProto.webkitMatchesSelector || elementProto.mozMatchesSelector || elementProto.msMatchesSelector || elementProto.oMatchesSelector || elementProto.matchesSelector || elementProto.matches || function(selector) {
const nodeList = doc.querySelectorAll ? (this.parentNode || doc).querySelectorAll(selector) || [] : $(selector);
let i = nodeList.length;
while (i--) if (nodeList[i] === this) return true;
return false;
};
this.matchMedia = "matchMedia" in win;
this.pushState = !!(win.history && win.history.pushState);
this.hashChange = "onhashchange" in win;
this.customElements = "registerElement" in doc;
const chrome = this.browser.chrome;
const mobileChrome = this.browser.crios;
const mozilla = this.browser.mozilla;
const safari = this.browser.safari;
this.msPointers = !chrome && win.MSPointerEvent;
this.pointers = !chrome && !mobileChrome && !mozilla && !safari && win.PointerEvent;
this.kineticScrollNeeded = !!(mobileOS && (mobileOS.device !== "ipad" || parseInt(mobileOS.majorVersion) < 13) && (this.touch || this.msPointers || this.pointers));
if (this.touch) if (!this.mobileOS) {
this.mousedown = "mousedown touchstart";
this.mouseup = "mouseup touchend";
this.mousemove = "mousemove touchmove";
this.mousecancel = "mouseleave touchcancel";
this.click = "click";
this.resize = "resize";
} else {
this.mousedown = "touchstart";
this.mouseup = "touchend";
this.mousemove = "touchmove";
this.mousecancel = "touchcancel";
this.click = "touchend";
this.resize = "orientationchange";
}
else if (this.pointers) {
this.mousemove = "pointermove";
this.mousedown = "pointerdown";
this.mouseup = "pointerup";
this.mousecancel = "pointercancel";
this.click = "pointerup";
this.resize = "orientationchange resize";
} else if (this.msPointers) {
this.mousemove = "MSPointerMove";
this.mousedown = "MSPointerDown";
this.mouseup = "MSPointerUp";
this.mousecancel = "MSPointerCancel";
this.click = "MSPointerUp";
this.resize = "orientationchange resize";
} else {
this.mousemove = "mousemove";
this.mousedown = "mousedown";
this.mouseup = "mouseup";
this.mousecancel = "mouseleave";
this.click = "click";
this.resize = "resize";
}
this.addBrowserCssClasses($);
}
/**
* Get or calculate scrollbar width
*/
scrollbar(refresh) {
if (!isNaN(this._scrollbar) && !refresh) return this._scrollbar;
const div = document.createElement("div");
div.style.cssText = "overflow:scroll;overflow-x:hidden;zoom:1;clear:both;display:block";
div.innerHTML = " ";
document.body.appendChild(div);
this._scrollbar = div.offsetWidth - div.scrollWidth;
document.body.removeChild(div);
return this._scrollbar;
}
/**
* Check if element is in RTL context
*/
isRtl(element) {
return $(element).closest(".k-rtl").length > 0;
}
/**
* Detect mobile operating system from user agent
*/
detectOS(ua) {
let os = false;
let minorVersion;
let match = null;
const notAndroidPhone = !/mobile safari/i.test(ua);
const agentRxs = {
wp: /(Windows Phone(?: OS)?)\s(\d+)\.(\d+(\.\d+)?)/,
fire: /(Silk)\/(\d+)\.(\d+(\.\d+)?)/,
android: /(Android|Android.*(?:Opera|Firefox).*?\/)\s*(\d+)\.?(\d+(\.\d+)?)?/,
iphone: /(iPhone|iPod).*OS\s+(\d+)[\._]([\d\._]+)/,
ipad: /(iPad).*OS\s+(\d+)[\._]([\d_]+)/,
meego: /(MeeGo).+NokiaBrowser\/(\d+)\.([\d\._]+)/,
webos: /(webOS)\/(\d+)\.(\d+(\.\d+)?)/,
blackberry: /(BlackBerry|BB10).*?Version\/(\d+)\.(\d+(\.\d+)?)/,
playbook: /(PlayBook).*?Tablet\s*OS\s*(\d+)\.(\d+(\.\d+)?)/,
windows: /(MSIE)\s+(\d+)\.(\d+(\.\d+)?)/,
tizen: /(tizen).*?Version\/(\d+)\.(\d+(\.\d+)?)/i,
sailfish: /(sailfish).*rv:(\d+)\.(\d+(\.\d+)?).*firefox/i,
ffos: /(Mobile).*rv:(\d+)\.(\d+(\.\d+)?).*Firefox/
};
const osRxs = {
ios: /^i(phone|pad|pod)$/i,
android: /^android|fire$/i,
blackberry: /^blackberry|playbook/i,
windows: /windows/,
wp: /wp/,
flat: /sailfish|ffos|tizen/i,
meego: /meego/
};
const formFactorRxs = { tablet: /playbook|ipad|fire/i };
const browserRxs = {
omini: /Opera\sMini/i,
omobile: /Opera\sMobi/i,
firefox: /Firefox|Fennec/i,
mobilesafari: /version\/.*safari/i,
ie: /MSIE|Windows\sPhone/i,
chrome: /chrome|crios/i,
webkit: /webkit/i,
edge: /edge|edg|edgios|edga/i
};
for (const agent in agentRxs) if (agentRxs.hasOwnProperty(agent)) {
match = ua.match(agentRxs[agent]);
if (match) {
if (agent === "windows" && "plugins" in navigator) return false;
os = {};
os.device = agent;
os.tablet = testRx(agent, formFactorRxs, false);
os.browser = testRx(ua, browserRxs, "default");
os.name = testRx(agent, osRxs);
os[os.name] = true;
os.majorVersion = match[2];
os.minorVersion = (match[3] || "0").replace("_", ".");
minorVersion = os.minorVersion.replace(".", "").substr(0, 2);
os.flatVersion = os.majorVersion + minorVersion + new Array(3 - (minorVersion.length < 3 ? minorVersion.length : 2)).join("0");
os.cordova = typeof window.PhoneGap !== UNDEFINED$2 || typeof window.cordova !== UNDEFINED$2;
os.appMode = !!navigator.standalone || /file|local|wmapp/.test(window.location.protocol) || os.cordova;
if (os.android && (this.devicePixelRatio < 1.5 && parseInt(os.flatVersion) < 400 || notAndroidPhone) && (this.screenWidth > 800 || this.screenHeight > 800)) os.tablet = agent;
break;
}
}
return os;
}
/**
* Detect browser from user agent
*/
detectBrowser(ua) {
let browser = false;
let match;
let chromiumEdgeMatch;
const browserRxs = {
edge: /(edge)[ \/]([\w.]+)/i,
webkit: /(chrome|crios)[ \/]([\w.]+)/i,
safari: /(webkit)[ \/]([\w.]+)/i,
opera: /(opera)(?:.*version|)[ \/]([\w.]+)/i,
msie: /(msie\s|trident.*? rv:)([\w.]+)/i,
mozilla: /(mozilla)(?:.*? rv:([\w.]+)|)/i
};
for (const agent in browserRxs) if (browserRxs.hasOwnProperty(agent)) {
match = ua.match(browserRxs[agent]);
if (match) {
browser = {};
browser[agent] = true;
browser[match[1].toLowerCase().split(" ")[0].split("/")[0]] = true;
browser.version = parseInt(document.documentMode || match[2], 10);
if (browser.chrome) {
chromiumEdgeMatch = ua.match(/(edg)[ \/]([\w.]+)/i);
if (chromiumEdgeMatch) browser.chromiumEdge = true;
}
break;
}
}
return browser || { version: 0 };
}
/**
* Detect clipboard command support
*/
detectClipboardAccess() {
const doc = document;
const commands = {
copy: doc.queryCommandSupported ? doc.queryCommandSupported("copy") : false,
cut: doc.queryCommandSupported ? doc.queryCommandSupported("cut") : false,
paste: doc.queryCommandSupported ? doc.queryCommandSupported("paste") : false
};
if (this.browser.chrome) {
commands.paste = false;
if (this.browser.version >= 43) {
commands.copy = true;
commands.cut = true;
}
}
return commands;
}
/**
* Get current zoom level
*/
zoomLevel() {
try {
const browser = this.browser;
let ie11WidthCorrection = 0;
const docEl = document.documentElement;
if (browser.msie && browser.version === 11 && docEl.scrollHeight > docEl.clientHeight && !this.touch) ie11WidthCorrection = this.scrollbar();
return this.touch ? docEl.clientWidth / window.innerWidth : browser.msie && browser.version >= 10 ? ((top || window).document.documentElement.offsetWidth + ie11WidthCorrection) / (top || window).innerWidth : 1;
} catch (e) {
return 1;
}
}
/**
* Check if device has delayed click behavior
*/
delayedClick() {
if (this.touch) {
const mobileOS = this.mobileOS;
if (mobileOS && mobileOS.ios) return true;
if (mobileOS && mobileOS.android) {
if (!this.browser.chrome) return true;
if (this.browser.version < 32) return false;
return !($("meta[name=viewport]").attr("content") || "").match(/user-scalable=no/i);
}
}
return false;
}
/**
* Detect native input type support
*/
detectInputTypes(input) {
const types = [
"number",
"date",
"time",
"month",
"week",
"datetime",
"datetime-local"
];
const value = "test";
const result = {};
for (const type of types) {
input.setAttribute("type", type);
input.value = value;
result[type.replace("-", "")] = input.type !== "text" && input.value !== value;
}
return result;
}
/**
* Detect if sort is stable
*/
detectStableSort() {
const threshold = 513;
const sorted = [{
index: 0,
field: "b"
}];
for (let i = 1; i < threshold; i++) sorted.push({
index: i,
field: "a"
});
sorted.sort((a, b) => {
return a.field > b.field ? 1 : a.field < b.field ? -1 : 0;
});
return sorted[0].index === 1;
}
/**
* Add browser-specific CSS classes to document element
*/
addBrowserCssClasses($) {
const browser = this.browser;
let cssClass = "";
const docElement = $(document.documentElement);
const majorVersion = parseInt(String(browser.version), 10);
if (browser.msie) cssClass = "ie";
else if (browser.mozilla) cssClass = "ff";
else if (browser.safari) cssClass = "safari";
else if (browser.webkit) cssClass = "webkit";
else if (browser.opera) cssClass = "opera";
else if (browser.edge) cssClass = "edge";
if (cssClass) cssClass = "k-" + cssClass + " k-" + cssClass + majorVersion;
if (this.mobileOS) cssClass += " k-mobile";
if (!this.cssFlexbox) cssClass += " k-no-flexbox";
docElement.addClass(cssClass);
}
/**
* Convert Bootstrap breakpoint name to CSS media query
*/
bootstrapToMedia(bootstrapMedia) {
return {
"xs": "(max-width: 576px)",
"sm": "(min-width: 576px)",
"md": "(min-width: 768px)",
"lg": "(min-width: 992px)",
"xl": "(min-width: 1200px)"
}[bootstrapMedia];
}
/**
* Check if a media query matches
* Supports both CSS media queries and Bootstrap breakpoint names
*/
matchesMedia(mediaQuery) {
const media = this.bootstrapToMedia(mediaQuery) || mediaQuery;
return this.matchMedia && window.matchMedia(media).matches;
}
};
const supportService = new SupportService();
//#endregion
//#region ../src/core/services/mouse-event-normalizer.service.ts
/**
* Mouse Event Normalizer Service
* Handles mouse event capturing and muting for touch/pointer event normalization.
*/
/**
* Mouse event normalizer service for handling touch/mouse event conflicts.
* Prevents ghost clicks and normalizes touch events to mouse events.
*/
var MouseEventNormalizerService = class {
constructor() {
this.mouseTrap = false;
this.bustClick = false;
this.captureMouse = false;
this.MOUSE_EVENTS = [
"mousedown",
"mousemove",
"mouseenter",
"mouseleave",
"mouseover",
"mouseout",
"mouseup",
"click"
];
this.EXCLUDE_BUST_CLICK_SELECTOR = "label, input, [data-rel=external]";
}
/**
* Set up mouse event capturing to prevent ghost clicks from touch events.
* This sets up event listeners on document.documentElement to intercept
* and optionally stop mouse events when touch events are active.
*/
setupMouseMute() {
let idx = 0;
const length = this.MOUSE_EVENTS.length;
const element = document.documentElement;
if (this.mouseTrap || !supportService.eventCapture) return;
this.mouseTrap = true;
this.bustClick = false;
this.captureMouse = false;
const self = this;
const handler = function(e) {
if (self.captureMouse) if (e.type === "click") {
if (self.bustClick && !$(e.target).is(self.EXCLUDE_BUST_CLICK_SELECTOR)) {
e.preventDefault();
e.stopPropagation();
}
} else e.stopPropagation();
};
for (; idx < length; idx++) element.addEventListener(this.MOUSE_EVENTS[idx], handler, true);
}
/**
* Mute mouse events. Called on touchstart to prevent ghost clicks.
* @param e - The jQuery event with bustClick data
*/
muteMouse(e) {
this.captureMouse = true;
if (e.data?.bustClick) this.bustClick = true;
clearTimeout(this.mouseTrapTimeoutID);
}
/**
* Unmute mouse events. Called on touchend after a delay to allow
* legitimate mouse events through again.
*/
unMuteMouse() {
clearTimeout(this.mouseTrapTimeoutID);
this.mouseTrapTimeoutID = setTimeout(() => {
this.captureMouse = false;
this.bustClick = false;
}, 400);
}
};
const mouseEventNormalizerService = new MouseEventNormalizerService();
//#endregion
//#region ../src/core/services/event-map.service.ts
/**
* Event Map Service
* Provides cross-browser event mapping for touch, pointer, and mouse events.
*/
/**
* Event map service for cross-browser event handling.
* Maps abstract event names (down, move, up, cancel) to the appropriate
* browser-specific events based on touch/pointer/mouse support.
*/
var EventMapService = class {
constructor() {
this.eventRegEx = /([^ ]+)/g;
this.eventMap = this.buildEventMap();
this.setupMSPointerEvents();
}
/**
* Build the event map based on browser capabilities
*/
buildEventMap() {
let map = {
down: "touchstart mousedown",
move: "mousemove touchmove",
up: "mouseup touchend touchcancel",
cancel: "mouseleave touchcancel"
};
if (supportService.touch && supportService.mobileOS && (supportService.mobileOS.ios || supportService.mobileOS.android)) map = {
down: "touchstart",
move: "touchmove",
up: "touchend touchcancel",
cancel: "touchcancel"
};
else if (supportService.pointers) map = {
down: "pointerdown",
move: "pointermove",
up: "pointerup",
cancel: "pointercancel pointerleave"
};
else if (supportService.msPointers) map = {
down: "MSPointerDown",
move: "MSPointerMove",
up: "MSPointerUp",
cancel: "MSPointerCancel MSPointerLeave"
};
return map;
}
/**
* Setup MSPointerEnter/MSPointerLeave events for IE10
* Creates these events using mouseover/out and event-time checks
*/
setupMSPointerEvents() {
if (supportService.msPointers && !("onmspointerenter" in window)) $.each({
MSPointerEnter: "MSPointerOver",
MSPointerLeave: "MSPointerOut"
}, (orig, fix) => {
$.event.special[orig] = {
delegateType: fix,
bindType: fix,
handle: function(event) {
let ret;
const target = this;
const related = event.relatedTarget;
const handleObj = event.handleObj;
if (!related || related !== target && !this.$.contains(target, related)) {
event.type = handleObj.origType;
ret = handleObj.handler.apply(this, arguments);
event.type = fix;
}
return ret;
}
};
});
}
/**
* Get the mapped event for an abstract event name
* @param eventName - The abstract event name (down, move, up, cancel) or specific event
* @returns The browser-specific event(s) or the original event if no mapping exists
*/
getEventMap(eventName) {
return this.eventMap[eventName] || eventName;
}
/**
* Get the full event map object
*/
getFullEventMap() {
return { ...this.eventMap };
}
/**
* Apply event mapping to a space-separated list of events
* @param events - Space-separated event names to map
* @param ns - Optional namespace to append to each event
* @returns The mapped and namespaced events
*/
applyEventMap(events, ns) {
events = events.replace(this.eventRegEx, (e) => this.getEventMap(e));
if (ns) events = events.replace(this.eventRegEx, "$1." + ns);
return events;
}
};
const eventMapService = new EventMapService();
//#endregion
//#region ../src/core/services/utils.service.ts
const OBJECT = "object";
const UNDEFINED$1 = "undefined";
/**
* Utility service providing general helper functions.
*/
var UtilsService = class {
constructor() {
this.keys = {
INSERT: 45,
DELETE: 46,
BACKSPACE: 8,
TAB: 9,
ENTER: 13,
ESC: 27,
LEFT: 37,
UP: 38,
RIGHT: 39,
DOWN: 40,
END: 35,
HOME: 36,
SPACEBAR: 32,
PAGEUP: 33,
PAGEDOWN: 34,
F2: 113,
F10: 121,
F12: 123,
SHIFT: 16,
NUMPAD_PLUS: 107,
NUMPAD_MINUS: 109,
NUMPAD_DOT: 110
};
this.days = {
Sunday: 0,
Monday: 1,
Tuesday: 2,
Wednesday: 3,
Thursday: 4,
Friday: 5,
Saturday: 6
};
}
/**
* Get kendo.data namespace (accessed at call time for lazy loading)
*/
get kendoData() {
return window.kendo?.data || {};
}
/**
* Convert camelCase to hyphen-case
*/
toHyphens(str) {
return str.replace(/([a-z][A-Z])/g, (g) => {
return g.charAt(0) + "-" + g.charAt(1).toLowerCase();
});
}
/**
* Convert hyphen-case to camelCase
*/
toCamelCase(str) {
return str.replace(/\-(\w)/g, (_strMatch, g1) => {
return g1.toUpperCase();
});
}
/**
* Count properties in an object (excluding toJSON for IE7 compat)
*/
size(obj) {
let result = 0;
for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key) && key !== "toJSON") result++;
return result;
}
/**
* Deep extend an object with one or more source objects.
*/
deepExtend(destination, ...sources) {
for (let i = 0; i < sources.length; i++) this.deepExtendOne(destination, sources[i]);
return destination;
}
/**
* Deep extend destination with a single source object.
* This is the core implementation that handles all the special cases.
*/
deepExtendOne(destination, source) {
const ObservableArray = this.kendoData.ObservableArray;
const LazyObservableArray = this.kendoData.LazyObservableArray;
const DataSource = this.kendoData.DataSource;
const HierarchicalDataSource = this.kendoData.HierarchicalDataSource;
for (const property in source) {
if (property === "__proto__" || property === "constructor" || property === "prototype") continue;
const propValue = source[property];
const propType = typeof propValue;
let propInit = null;
if (propType === OBJECT && propValue !== null) propInit = propValue.constructor;
let isRegExp = propInit?.name === "RegExp";
let isArrayBuffer = propInit?.name === "ArrayBuffer";
let isDate = propInit?.name === "Date";
if (propInit && !Array.isArray(propValue) && propInit !== ObservableArray && propInit !== LazyObservableArray && propInit !== DataSource && propInit !== HierarchicalDataSource && !isRegExp && (!this.isFunction(window.ArrayBuffer) || !isArrayBuffer) && !(propValue instanceof HTMLElement)) if (isDate) destination[property] = new Date(propValue.getTime());
else if (this.isCloneable(propValue)) destination[property] = propValue.clone();
else {
const destProp = destination[property];
if (typeof destProp === OBJECT) destination[property] = destProp || {};
else destination[property] = {};
this.deepExtendOne(destination[property], propValue);
}
else if (propType !== UNDEFINED$1) destination[property] = propValue;
}
return destination;
}
/**
* Check if an object has a clone method
*/
isCloneable(obj) {
return typeof obj.clone === "function";
}
/**
* Create a throttled version of a function.
* The throttled function will only execute at most once per delay period.
* Includes a cancel() method to clear any pending execution.
*
* If delay is falsy (0, null, undefined), returns the original function unchanged.
*/
throttle(fn, delay) {
if (!delay || delay <= 0) return fn;
let timeout;
let lastExecTime = 0;
const throttled = function(...args) {
const that = this;
const elapsed = +/* @__PURE__ */ new Date() - lastExecTime;
function exec() {
const result = fn.apply(that, args);
lastExecTime = +/* @__PURE__ */ new Date();
return result;
}
if (!lastExecTime) return exec();
if (timeout) clearTimeout(timeout);
if (elapsed > delay) return exec();
else timeout = setTimeout(exec, delay - elapsed);
};
throttled.cancel = function() {
if (timeout) {
clearTimeout(timeout);
timeout = void 0;
}
};
return throttled;
}
/**
* Generate a UUID.
* Uses crypto.randomUUID() when available (HTTPS only),
* falls back to crypto.getRandomValues().
*/
guid() {
const cryptoObj = window.crypto;
try {
return cryptoObj.randomUUID();
} catch (e) {
return cryptoObj.getRandomValues(/* @__PURE__ */ new Uint8Array(16)).reduce((acc, curr, i) => {
if (i === 4 || i === 6 || i === 8 || i === 10) acc += "-";
acc += curr.toString(16).padStart(2, "0");
return acc;
}, "");
}
}
/**
* Trim whitespace from a value.
* Converts to string first, returns empty string for falsy values.
*/
trim(value) {
if (value) return value.toString().trim();
return "";
}
/**
* Check if a value is present (not null and not undefined)
*/
isPresent(value) {
return value !== null && value !== void 0;
}
/**
* Check if a value is blank (null or undefined)
*/
isBlank(value) {
return value === null || value === void 0;
}
/**
* Check if a value is empty (has length 0)
*/
isEmpty(value) {
return value.length === 0;
}
/**
* Check if a value is a string
*/
isString(value) {
return typeof value === "string";
}
/**
* Check if a value is an integer
*/
isInteger(value) {
return Number.isInteger(value);
}
/**
* Check if a value is numeric
*/
isNumeric(value) {
return !isNaN(value - parseFloat(value));
}
/**
* Check if a value is a Date object
*/
isDate(value) {
return value && value.getTime;
}
/**
* Check if a value is a function
*/
isFunction(value) {
return typeof value === "function";
}
/**
* Check if a value is an object (and not null)
*/
isObject(value) {
return value !== null && typeof value === OBJECT;
}
/**
* Log a message to the console.
* Respects kendo.suppressLog setting.
* @param message - The message to log
* @param type - Console method to use ("log", "warn", "error", etc.). Defaults to "log"
*/
logToConsole(message, type) {
const console = window.console;
if (!window.kendo.suppressLog && typeof console !== "undefined" && console.log) console[type || "log"](message);
}
/**
* Wait for all promises to resolve, similar to Promise.all but for jQuery Deferreds.
* Unlike $.when(), this handles failures gracefully and reports all results.
*
* Influenced from: https://gist.github.com/fearphage/4341799
*
* @param array - Array of deferreds/promises, or multiple arguments
* @returns A jQuery Promise that resolves when all inputs resolve, or rejects if any fail
*/
whenAll(array) {
const $ = window.jQuery;
const resolveValues = arguments.length === 1 && Array.isArray(array) ? array : Array.prototype.slice.call(arguments);
const length = resolveValues.length;
let remaining = length;
const deferred = $.Deferred();
let i = 0;
let failed = 0;
const rejectContexts = new Array(length);
const rejectValues = new Array(length);
const resolveContexts = new Array(length);
let value;
const updateFunc = (index, contexts, values) => {
return function() {
if (values !== resolveValues) failed++;
deferred.notifyWith(contexts[index] = this, values[index] = Array.prototype.slice.call(arguments));
if (!--remaining) deferred[(!failed ? "resolve" : "reject") + "With"](contexts, values);
};
};
for (; i < length; i++) {
value = resolveValues[i];
if (value && this.isFunction(value.promise)) value.promise().done(updateFunc(i, resolveContexts, resolveValues)).fail(updateFunc(i, rejectContexts, rejectValues));
else {
deferred.notifyWith(this, value);
--remaining;
}
}
if (!remaining) deferred.resolveWith(resolveContexts, resolveValues);
return deferred.promise();
}
/**
* Check if a URL is local (doesn't start with a protocol)
* @param url - URL to check
* @returns True if the URL is local
*/
isLocalUrl(url) {
return url && !/^([a-z]+:)?\/\//i.test(url);
}
/**
* Get all method names (static and instance) from a class
* @param targetClass - The class to inspect
* @returns Array of method names
*/
getAllMethods(targetClass) {
const allStatic = Object.getOwnPropertyNames(targetClass).filter((prop) => typeof targetClass[prop] === "function");
const allNonStatic = Object.getOwnPropertyNames(Object.getPrototypeOf(new targetClass({}))).filter((prop) => prop !== "constructor");
return allStatic.concat(allNonStatic);
}
/**
* Get the base class (parent class) of a given class
* @param targetClass - The class to get the parent of
* @returns The parent class or null if none
*/
getBaseClass(targetClass) {
if (targetClass instanceof Function) {
const newBaseClass = Object.getPrototypeOf(targetClass);
if (newBaseClass && newBaseClass !== Object && newBaseClass.name) return newBaseClass;
}
return null;
}
/**
* Create a proxy member on a prototype that delegates to an instance
* @param proto - The prototype object to add the member to
* @param name - The name of the member to create
*/
createProxyMember(proto, name) {
proto.fn[name] = function() {
const instance = this._instance;
if (instance) return instance[name].apply(instance, arguments);
};
}
/**
* Convert a native Promise to a jQuery Deferred
* @param promise - The native Promise to convert
* @returns A jQuery Promise
*/
convertPromiseToDeferred(promise) {
const deferred = $.Deferred();
promise.finally(deferred.always).then(deferred.resolve).catch(deferred.reject);
return deferred.promise();
}
};
const utilsService = new UtilsService();
//#endregion
//#region ../src/core/services/kendo-jquery.service.ts
/**
* KendoJQuery Service
*
* Provides a jQuery wrapper with Kendo-specific functionality:
* - Event namespacing with automatic cleanup
* - Handler context binding
* - Touch/mouse event normalization
* - Keyboard event handling
*/
const STRING$5 = "string";
const UNDEFINED = "undefined";
/**
* KendoJQuery Service
* Creates and manages the KendoJQuery wrapper around jQuery
*/
var KendoJQueryService = class {
constructor() {
this.originalOn = $.fn.on;
this.kendoJQuery = this.createKendoJQuery();
this.rootjQuery = this.kendoJQuery(document);
}
/**
* Extend objects while avoiding jQuery deprecated properties
*/
noDeprecateExtend(deep, target, ...sources) {
let src, copyIsArray, copy, name, clone;
if (typeof target !== "object" && typeof target !== "function") target = {};
for (const source of sources) if (source != null) for (name in source) {
if (name === "filters" || name === "concat" || name === ":" || name === "cssNumber") continue;
src = target[name];
copy = source[name];
if (target === copy) continue;
if (deep && copy && ($.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && Array.isArray(src) ? src : [];
} else clone = src && $.isPlainObject(src) ? src : {};
target[name] = this.noDeprecateExtend(deep, clone, copy);
} else if (copy !== void 0) target[name] = copy;
}
return target;
}
/**
* Create the KendoJQuery constructor and prototype
*/
createKendoJQuery() {
const self = this;
const kendoJQuery = function(selector, context) {
return new kendoJQuery.fn.init(selector, context);
};
this.noDeprecateExtend(true, kendoJQuery, $);
kendoJQuery.fn = kendoJQuery.prototype = new $();
kendoJQuery.fn.constructor = kendoJQuery;
kendoJQuery.fn.init = function(selector, context) {
if (context && context instanceof $ && !(context instanceof kendoJQuery)) context = kendoJQuery(context);
return $.fn.init.call(this, selector, context, self.rootjQuery);
};
kendoJQuery.fn.init.prototype = kendoJQuery.fn;
$.extend(kendoJQuery.fn, {
handler: function(handler) {
this.data("handler", handler);
return this;
},
autoApplyNS: function(ns) {
this.data("kendoNS", ns || utilsService.guid());
return this;
},
on: function(...args) {
const that = this;
const ns = that.data("kendoNS");
const on = self.originalOn;
if (args.length === 1) return on.call(that, args[0]);
let context = that;
const argsCopy = args.slice();
if (typeof argsCopy[argsCopy.length - 1] === UNDEFINED) argsCopy.pop();
const callback = argsCopy[argsCopy.length - 1];
const events = eventMapService.applyEventMap(argsCopy[0], ns);
if (supportService.mouseAndTouchPresent && events.search(/mouse|click/) > -1 && this[0] !== document.documentElement) {
mouseEventNormalizerService.setupMouseMute();
const selector = argsCopy.length === 2 ? null : argsCopy[1];
const bustClick = events.indexOf("click") > -1 && events.indexOf("touchend") > -1;
on.call(this, {
touchstart: (e) => mouseEventNormalizerService.muteMouse(e),
touchend: () => mouseEventNormalizerService.unMuteMouse()
}, selector, { bustClick });
}
if (argsCopy[0].indexOf("keydown") !== -1 && argsCopy[1] && argsCopy[1].options) {
argsCopy[0] = events;
const widget = argsCopy[1];
const keyDownCallback = argsCopy[argsCopy.length - 1];
argsCopy[argsCopy.length - 1] = function(e) {
if (self.keyDownHandler(e, widget)) return keyDownCallback.apply(this, [e]);
};
on.apply(that, argsCopy);
return that;
}
if (typeof callback === STRING$5) {
context = that.data("handler");
const callbackFn = context[callback];
argsCopy[argsCopy.length - 1] = function(e) {
callbackFn.call(context, e);
};
}
argsCopy[0] = events;
on.apply(that, argsCopy);
return that;
},
kendoDestroy: function(ns) {
ns = ns || this.data("kendoNS");
if (ns) this.off("." + ns);
return this;
}
});
return kendoJQuery;
}
/**
* Get the KendoJQuery constructor function
*/
getConstructor() {
return this.kendoJQuery;
}
/**
* Create a KendoJQuery wrapper
*/
create(selector, context) {
return this.kendoJQuery(selector, context);
}
/**
* Handle keydown events for a widget
* Executes all kendoKeydown handlers and checks if event should be prevented
*/
keyDownHandler(e, widget) {
const events = widget._events.kendoKeydown;
if (!events) return true;
const eventsCopy = events.slice();
e.sender = widget;
e.preventKendoKeydown = false;
for (let idx = 0, length = eventsCopy.length; idx < length; idx++) eventsCopy[idx].call(widget, e);
return !e.preventKendoKeydown;
}
};
const kendoJQueryService = new KendoJQueryService();
//#endregion
//#region ../src/core/base/class.ts
/**
* Base Class for Kendo UI.
* All Kendo classes inherit from this base class.
*/
var Class = class {
/**
* Creates a subclass with the given prototype.
* This is the legacy extend pattern used throughout Kendo UI.
*
* This method:
* 1. Creates a new constructor function that extends the current class
* 2. Copies all properties from proto to the new prototype
* 3. For plain object members, performs deep merge with base class members using $.extend
* 4. Sets up the extend method on the subclass for further inheritance
*
* @param proto - Object containing methods and properties for the subclass
* @returns New constructor function for the subclass
*
* @example
* var MyClass = Class.extend({
* init: function(options) {
* this.options = options;
* },
* myMethod: function() {
* return this.options;
* }
* });
*
* var instance = new MyClass({ foo: 'bar' });
*/
static extend(proto) {
const that = this;
const base = function() {};
base.prototype = that.prototype;
const subclass = proto && proto.init ? proto.init : function(...args) {
if (that.prototype.init) that.prototype.init.apply(this, args);
};
const fn = subclass.fn = subclass.prototype = new base();
if (proto) for (const member in proto) if (proto[member] != null && proto[member].constructor === Object) fn[member] = kendoJQueryService.getConstructor().extend(true, {}, base.prototype[member], proto[member]);
else fn[member] = proto[member];
fn.constructor = subclass;
subclass.extend = that.extend;
return subclass;
}
};
Class.fn = Class.prototype;
/**
* Define init and _initOptions on the prototype as ENUMERABLE properties.
*
* ES6 class methods are non-enumerable by default, which breaks the
* legacy extend() pattern because when we do:
* base.prototype = that.prototype;
* fn = new base();
*
* The inherited methods from the ES6 class prototype don't appear in
* for...in loops or when the object is logged/inspected. This causes
* issues when deepExtend copies class instances - the non-enumerable
* methods are not properly inherited through the prototype chain.
*
* By defining these methods directly on the prototype (like the original
* Kendo Class did), we ensure they're enumerable and properly inherited.
*/
Class.prototype.init = function(..._args) {};
Class.prototype._initOptions = function(options) {
this.options = kendoJQueryService.getConstructor().extend(true, {}, this.options, options);
};
//#endregion
//#region ../src/core/base/observable.ts
/**
* Kendo UI Observable Class
*
* Provides event binding, unbinding, and triggering functionality.
* This is the foundation for all event-driven components in Kendo UI.
*
* Extends Class and supports both ES6 and legacy extend() patterns.
*
*
* @example
* // ES6 class inheritance
* class MyComponent extends Observable {
* doSomething() {
* this.trigger("change", { value: 42 });
* }
* }
*
* @example
* // Legacy extend pattern
* const MyComponent = Observable.extend({
* init: function() {
* Observable.fn.init.call(this);
* this.value = 0;
* },
* setValue: function(val) {
* this.value = val;
* this.trigger("change", { value: val });
* }
* });
*
* const component = new MyComponent();
* component.bind("change", function(e) {
* console.log("Value changed to:", e.value);
* });
* component.setValue(42);
*/
const STRING$4 = "string";
const FUNCTION$2 = "function";
/**
* preventDefault helper function.
* Called on event object to prevent default action.
* Uses regular function to preserve `this` context (the event object).
*/
function preventDefault() {
this._defaultPrevented = true;
}
/**
* isDefaultPrevented helper function.
* Called on event object to check if default was prevented.
* Uses regular function to preserve `this` context (the event object).
*/
function isDefaultPrevented() {
return this._defaultPrevented === true;
}
/**
* Observable class for event handling.
* All Kendo UI widgets and data components inherit from this class.
*/
var Observable = class extends Class {
/**
* Constructor - initializes the Observable's _events storage.
*/
constructor() {
super();
this._events = {};
}
/**
* Initialize the Observable instance.
* Sets up the internal _events storage.
* Accepts any arguments to allow subclasses to override with different signatures.
*
* Note: For direct Observable usage, this is called by the constructor.
* For subclasses, they should call Observable.fn.init.call(this) in their init.
*/
init(..._args) {
this._events = {};
}
/**
* Binds one or more event handlers to the observable.
*
* Supports multiple calling patterns:
* - bind("event", handler)
* - bind(["event1", "event2"], handler)
* - bind({ event1: handler1, event2: handler2 })
* - bind("event", handler, true) // one-time binding
*
* @param eventName - Event name, array of names, or object map
* @param handlers - Handler function or map of handlers
* @param one - If true, handler is removed after first invocation
* @returns this for chaining
*/
bind(eventName, handlers, one) {
const that = this;
let idx;
let length;
let original;
let handler;
const handlersIsFunction = typeof handlers === FUNCTION$2;
let events;
if (handlers === void 0) {
const eventMap = eventName;
for (idx in eventMap) that.bind(idx, eventMap[idx]);
return that;
}
const eventNames = typeof eventName === STRING$4 ? [eventName] : eventName;
for (idx = 0, length = eventNames.length; idx < length; idx++) {
const currentEventName = eventNames[idx];
handler = handlersIsFunction ? handlers : handlers[currentEventName];
if (handler) {
if (one) {
original = handler;
handler = (function(evtName, originalHandler) {
const wrappedHandler = function() {
that.unbind(evtName, wrappedHandler);
originalHandler.apply(that, arguments);
};
wrappedHandler.original = originalHandler;
return wrappedHandler;
})(currentEventName, original);
}
events = that._events[currentEventName] = that._events[currentEventName] || [];
events.push(handler);
}
}
return that;
}
/**
* Binds an event handler that will be removed after first invocation.
*
* @param eventNames - Event name or array of names
* @param handlers - Handler function or map of handlers
* @returns this for chaining
*/
one(eventNames, handlers) {
return this.bind(eventNames, handlers, true);
}
/**
* Binds an event handler at the beginning of the handler list.
* The handler will be invoked before other handlers.
*
* @param eventName - Event name or array of names
* @param handlers - Handler function or map of handlers
* @returns this for chaining
*/
first(eventName, handlers) {
const that = this;
let idx;
const eventNames = typeof eventName === STRING$4 ? [eventName] : eventName;
const length = eventNames.length;
let handler;
const handlersIsFunction = typeof handlers === FUNCTION$2;
let events;
for (idx = 0; idx < length; idx++) {
const currentEventName = eventNames[idx];
handler = handlersIsFunction ? handlers : handlers[currentEventName];
if (handler) {
events = that._events[currentEventName] = that._events[currentEventName] || [];
events.unshift(handler);
}
}
return that;
}
/**
* Triggers an event, invoking all bound handlers.
*
* @param eventName - Name of the event to trigger
* @param e - Optional event data object
* @returns true if preventDefault() was called, false otherwise
*/
trigger(eventName, e) {
const that = this;
let events = that._events[eventName];
let idx;
const length = events ? events.length : 0;
if (events) {
const eventObj = e || {};
eventObj.sender = that;
eventObj._defaultPrevented = false;
eventObj.preventDefault = preventDefault;
eventObj.isDefaultPrevented = isDefaultPrevented;
events = events.slice();
for (idx = 0; idx < length; idx++) events[idx].call(that, eventObj);
return eventObj._defaultPrevented === true;
}
return false;
}
/**
* Unbinds event handlers.
*
* - unbind() - removes all handlers for all events
* - unbind("event") - removes all handlers for specific event
* - unbind("event", handler) - removes specific handler
*
* @param eventName - Optional event name
* @param handler - Optional specific handler to remove
* @returns this for chaining
*/
unbind(eventName, handler) {
const that = this;
const events = eventName ? that._events[eventName] : void 0;
let idx;
if (eventName === void 0) that._events = {};
else if (events) if (handler) {
for (idx = events.length - 1; idx >= 0; idx--) if (events[idx] === handler || events[idx].original === handler) events.splice(idx, 1);
} else that._events[eventName] = [];
return that;
}
};
/**
* Make Observable methods ENUMERABLE by deleting and reassigning them.
*
* ES6 class methods are non-enumerable by default, which breaks legacy patterns
* like `$.extend({}, observableInstance, ...)` which copies properties using
* for...in loops. By deleting and reassigning, we create enumerable properties.
*/
const proto = Observable.prototype;
[
"init",
"bind",
"one",
"first",
"trigger",
"unbind"
].forEach((method) => {
const fn = proto[method];
Object.defineProperty(proto, method, {
value: fn,
writable: true,
configurable: true,
enumerable: true
});
});
Observable.fn = Observable.prototype;
//#endregion
//#region ../src/core/services/namespace.service.ts
/**
* Namespace Service
*
* Manages the data attribute namespace prefix used throughout Kendo UI.
* This allows customization of data-role attributes (e.g., data-kendo-role instead of data-role).
*/
var NamespaceService = class {
constructor() {
this._ns = "";
}
/**
* Get the current namespace prefix
*/
get ns() {
return this._ns;
}
/**
* Set the namespace prefix
* @param value - The namespace prefix (e.g., "kendo-")
*/
setNs(value) {
this._ns = value;
}
};
const namespaceService = new NamespaceService();
//#endregion
//#region ../src/core/services/dom-utils.service.ts
const PERCENT_REGEXP = /%/;
const BOX_SHADOW_REGEXP = /(\d+(?:\.?)\d*)px\s*(\d+(?:\.?)\d*)px\s*(\d+(?:\.?)\d*)px\s*(\d+)?/i;
/**
* Service providing DOM utility functions
*/
var DomUtilsService = class {
constructor() {
this.animationQueue = [];
const win = window;
this.animationFrameFn = win.requestAnimationFrame || win.webkitRequestAnimationFrame || win.mozRequestAnimationFrame || win.oRequestAnimationFrame || win.msRequestAnimationFrame || ((callback) => {
setTimeout(callback, 1e3 / 60);
});
}
isElement(element) {
return element instanceof Element || element instanceof HTMLDocument;
}
/**
* Get outer width of element
*/
outerWidth(element, includeMargin, calculateFromHidden) {
const $element = $(element);
if (calculateFromHidden) return this.getHiddenDimensions($element, includeMargin).width;
return $element.outerWidth(includeMargin || false) || 0;
}
/**
* Get outer height of element
*/
outerHeight(element, includeMargin, calculateFromHidden) {
const $element = $(element);
if (calculateFromHidden) return this.getHiddenDimensions($element, includeMargin).height;
return $element.outerHeight(includeMargin || false) || 0;
}
/**
* Get computed styles for an element
*/
getComputedStyles(element, properties) {
const styles = {};
let computedStyle;
if (document.defaultView && document.defaultView.getComputedStyle) {
computedStyle = document.defaultView.getComputedStyle(element, "");
if (properties) $.each(properties, (_idx, value) => {
styles[value] = computedStyle.getPropertyValue(value);
});
} else {
computedStyle = element.currentStyle;
if (properties) $.each(properties, (_idx, value) => {
styles[value] = computedStyle[utilsService.toCamelCase(value)];
});
}
if (!utilsService.size(styles)) return computedStyle;
return styles;
}
/**
* Check if an element is scrollable
*/
isScrollable(element) {
if (element.dataset[namespaceService.ns + "scrollable"] === "false") return false;
if (typeof element.className === "string" && element.className.indexOf("k-auto-scrollable") > -1) return true;
const overflow = this.getComputedStyles(element, ["overflow"]).overflow || "";
return overflow.indexOf("auto") > -1 || overflow.indexOf("scroll") > -1;
}
/**
* Get or set scroll left position (RTL-aware)
*/
scrollLeft(element, value) {
const webkit = supportService.browser.webkit;
const mozilla = supportService.browser.mozilla;
const browserVersion = supportService.browser.version;
if (element instanceof $ && value !== void 0) {
element.each((_i, e) => {
this.scrollLeft(e, value);
});
return;
}
const el = element instanceof $ ? element[0] : element;
if (!el) return;
const isRtl = supportService.isRtl(element);
if (value !== void 0) if (isRtl && webkit && (browserVersion < 85 || supportService.browser.safari)) el.scrollLeft = el.scrollWidth - el.clientWidth - value;
else if (isRtl && (mozilla || webkit) && value > 0) el.scrollLeft = -value;
else el.scrollLeft = value;
else if (isRtl && webkit && (browserVersion < 85 || supportService.browser.safari)) return el.scrollWidth - el.clientWidth - el.scrollLeft;
else return Math.abs(el.scrollLeft);
}
/**
* Get element offset position
*/
getOffset(element, type = "offset", positioned) {
const offset = element[type]();
const result = {
top: offset.top,
right: offset.right,
bottom: offset.bottom,
left: offset.left
};
if (supportService.browser.msie && (supportService.pointers || supportService.msPointers) && !positioned) {
const sign = supportService.isRtl(element) ? 1 : -1;
result.top -= window.pageYOffset - document.documentElement.scrollTop;
result.left -= window.pageXOffset + sign * document.documentElement.scrollLeft;
}
return result;
}
/**
* Get dimensions of a hidden element by temporarily cloning and showing it
*/
getHiddenDimensions(element, includeMargin) {
const clone = element.clone();
clone.css("display", "");
clone.css("visibility", "hidden");
clone.appendTo($("body"));
const width = clone.outerWidth(includeMargin || false);
const height = clone.outerHeight(includeMargin || false);
clone.remove();
return {
width: width || 0,
height: height || 0
};
}
/**
* Parse effects string into object
*/
parseEffects(input) {
const effects = {};
const items = typeof input === "string" ? input.split(" ") : input;
$.each(items, function(idx) {
effects[idx] = this;
});
return effects;
}
/**
* Remove whitespace text nodes from an element
*/
stripWhitespace(element) {
if (document.createNodeIterator) {
const iterator = document.createNodeIterator(element, NodeFilter.SHOW_TEXT, (node) => {
return node.parentNode === element ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
});
while (iterator.nextNode()) {
const refNode = iterator.referenceNode;
if (refNode && !refNode.textContent?.trim()) refNode.parentNode?.removeChild(refNode);
}
}
}
/**
* Request animation frame wrapper
*/
animationFrame(callback) {
this.animationFrameFn.call(window, callback);
}
/**
* Queue an animation callback
*/
queueAnimation(callback) {
this.animationQueue.push(callback);
if (this.animationQueue.length === 1) this.runNextAnimation();
}
/**
* Run the next animation in queue
*/
runNextAnimation() {
this.animationFrame(() => {
if (this.animationQueue[0]) {
this.animationQueue.shift()();
if (this.animationQueue[0]) this.runNextAnimation();
}
});
}
/**
* Parse query string parameters from URL
*/
parseQueryStringParams(url) {
const queryString = url.split("?")[1] || "";
const params = {};
const paramParts = queryString.split(/&|=/);
const length = paramParts.length;
for (let idx = 0; idx < length; idx += 2) if (paramParts[idx] !== "") params[decodeURIComponent(paramParts[idx])] = decodeURIComponent(paramParts[idx + 1]);
return params;
}
/**
* Get element under cursor position
*/
elementUnderCursor(e) {
if (typeof e.x.client !== "undefined") return document.elementFromPoint(e.x.client, e.y.client);
return null;
}
/**
* Get wheel delta Y from jQuery event
*/
wheelDeltaY(jQueryEvent) {
const e = jQueryEvent.originalEvent;
const deltaY = e.wheelDeltaY;
let delta;
if (e.wheelDelta) {
if (deltaY === void 0 || deltaY) delta = e.wheelDelta;
} else if (e.detail && e.axis === e.VERTICAL_AXIS) delta = -e.detail * 10;
return delta;
}
/**
* Get box-shadow dimensions from an element
*/
getShadows(element) {
const shadow = element.css("box-shadow");
const radius = shadow ? BOX_SHADOW_REGEXP.exec(shadow) || [
0,
0,
0,
0,
0
] : [
0,
0,
0,
0,
0
];
const blur = Math.max(+radius[3], +(radius[4] || 0));
return {
left: -radius[1] + blur,
right: +radius[1] + blur,
bottom: +radius[2] + blur
};
}
/**
* Wrap element with animation container
*/
wrap(element, autosize, resize, shouldCorrectWidth = true, autowidth) {
let parent = element.parent();
const windowOuterWidth = this.outerWidth(window);
parent.parent().removeClass("k-animation-container-sm");
if (!parent.hasClass("k-child-animation-container")) {
const width = element[0].style.width;
const height = element[0].style.height;
const percentWidth = PERCENT_REGEXP.test(width);
const percentHeight = PERCENT_REGEXP.test(height);
const forceDimensions = element.hasClass("k-tooltip") || element.is(".k-menu-horizontal.k-context-menu");
const calculateFromHidden = element.hasClass("k-tooltip");
const percentage = percentWidth || percentHeight;
let computedWidth = width;
let computedHeight = height;
if (!percentWidth && (!autosize || autosize && width || forceDimensions)) computedWidth = autosize ? this.outerWidth(element, false, calculateFromHidden) + 1 : this.outerWidth(element, false, calculateFromHidden);
if (!percentHeight && (!autosize || autosize && height) || forceDimensions) computedHeight = this.outerHeight(element, false, calculateFromHidden);
element.wrap($("<div/>").addClass("k-child-animation-container").css({
width: autowidth ? "auto" : computedWidth,
height: computedHeight
}));
parent = element.parent();
parent.wrap($("<div/>").addClass("k-animation-container").attr("role", "region"));
if (percentage) element.css({
width: "100%",
height: "100%"
});
} else this.wrapResize(element, autosize, shouldCorrectWidth);
parent = parent.parent();
if (windowOuterWidth < this.outerWidth(parent)) {
parent.addClass("k-animation-container-sm");
resize = true;
}
if (resize) this.wrapResize(element, autosize, shouldCorrectWidth);
return parent;
}
/**
* Resize wrapped element
*/
wrapResize(element, autosize, shouldCorrectWidth = true) {
const parent = element.parent();
const wrapper = element.closest(".k-animation-container");
const calculateFromHidden = element.hasClass("k-tooltip");
const visible = element.is(":visible");
const wrapperStyle = parent[0].style;
const elementHeight = element[0].style.height;
if (wrapper.is(":hidden")) wrapper.css({
display: "",
position: ""
});
if (!(PERCENT_REGEXP.test(wrapperStyle.width) || PERCENT_REGEXP.test(wrapperStyle.height))) {
if (!visible) element.add(parent).show();
if (shouldCorrectWidth) parent.css("width", "");
parent.css({ width: autosize ? this.outerWidth(element, false, calculateFromHidden) + 1 : this.outerWidth(element, false, calculateFromHidden) });
if (elementHeight === "auto") element.css({ height: this.outerHeight(parent) });
else parent.css({ height: this.outerHeight(element) });
if (!visible) element.hide();
}
}
/**
* Scroll element horizontally by a delta
*/
scrollByDelta(element, delta) {
const isRtl = supportService.isRtl(element);
const scrollDestination = (isRtl ? -this.scrollLeft(element) : this.scrollLeft(element)) + delta;
const scrollWidth = element[0].scrollWidth - element[0].clientWidth;
const animationProps = { "scrollLeft": scrollDestination };
element.finish().animate(animationProps, "fast", "linear");
const maxScroll = isRtl ? -scrollWidth : scrollWidth;
const newScrollLeft = isRtl ? Math.max(Math.min(scrollDestination, 0), maxScroll) : Math.min(Math.max(scrollDestination, 0), maxScroll);
return {
atStart: newScrollLeft === 0,
atEnd: newScrollLeft === maxScroll
};
}
/**
* Scroll element vertically by a delta
*/
scrollVerticalByDelta(element, delta, options = {}) {
const { duration = "fast", easing = "linear" } = options;
const targetScrollTop = (element.scrollTop() || 0) + delta;
const animationProps = { "scrollTop": targetScrollTop };
element.finish().animate(animationProps, duration, easing);
const maxScroll = element[0].scrollHeight - element[0].clientHeight;
const newScrollTop = Math.min(Math.max(targetScrollTop, 0), maxScroll);
return {
atTop: newScrollTop === 0,
atBottom: newScrollTop >= maxScroll
};
}
/**
* Smoothly scroll to a specific element within a container
*/
scrollToElement(container, targetElement, options = {}) {
if (!container.length || !targetElement.length) return false;
const { duration = 0, easing = "linear", position = "center", offset = 0, onComplete } = options;
const containerHeight = container.height() || 0;
const containerScrollTop = container.scrollTop() || 0;
const containerOffset = container.offset();
const targetOffset = targetElement.offset();
const targetHeight = targetElement.outerHeight() || 0;
const relativeTop = targetOffset.top - containerOffset.top + containerScrollTop;
let targetScrollTop;
switch (position) {
case "top":
targetScrollTop = relativeTop + offset;
break;
case "bottom":
targetScrollTop = relativeTop - containerHeight + targetHeight + offset;
break;
default:
targetScrollTop = relativeTop - containerHeight / 2 + targetHeight / 2 + offset;
break;
}
const maxScroll = container[0].scrollHeight - container[0].clientHeight;
targetScrollTop = Math.min(Math.max(targetScrollTop, 0), maxScroll);
container.finish().animate({ scrollTop: targetScrollTop }, duration, easing, onComplete);
return true;
}
/**
* Add a value to an element's attribute, avoiding duplicates
* If the value already exists in the attribute, it won't be added again
*/
addAttribute(element, attribute, value) {
const current = element.attr(attribute) || "";
if (current.indexOf(value) < 0) element.attr(attribute, (current + " " + value).trim());
}
/**
* Remove an attribute from an element
*/
removeAttribute(element, attribute) {
element.removeAttr(attribute);
}
/**
* Toggle an attribute value on an element
* For regular attributes: adds if not present, removes if present
* For disabled/readonly: adds only when value is truthy
*/
toggleAttribute(element, attribute, value) {
const doesNotHaveAttribute = (element.attr(attribute) || "").indexOf(value) < 0;
const disabledReadonly = ["disabled", "readonly"].indexOf(attribute) > -1;
if (doesNotHaveAttribute && !disabledReadonly) this.addAttribute(element, attribute, value);
else if (disabledReadonly && value) this.addAttribute(element, attribute, value);
else this.removeAttribute(element, attribute);
}
/**
* Bind a callback to the window resize event.
* On Android, the callback is delayed by 600ms to handle orientation changes properly.
* @param callback - Function to call on resize
* @returns The handler function (may be wrapped on Android)
*/
onResize(callback) {
let handler = callback;
if (supportService.mobileOS && supportService.mobileOS.android) handler = function() {
setTimeout(callback, 600);
};
$(window).on(supportService.resize, handler);
return handler;
}
/**
* Unbind a resize callback from the window.
* @param callback - The handler returned from onResize
*/
unbindResize(callback) {
$(window).off(supportService.resize, callback);
}
/**
* Get a data attribute value from an element using kendo namespace.
* @param element - jQuery element
* @param key - Attribute key (without kendo namespace prefix)
* @returns The attribute value
*/
attrValue(element, key) {
return element.data(namespaceService.ns + key);
}
/**
* Get the kendo data attribute name with namespace prefix.
* @param value - The attribute name without prefix
* @returns The full attribute name (e.g., "data-kendo-role" or "data-role")
*/
attr(value) {
return "data-" + namespaceService.ns + value;
}
/**
* Get or set element dimensions.
* @param element - jQuery element
* @param dimensions - Optional dimensions to set
* @returns Object with width and height
*/
dimensions(element, dimensions) {
const domElement = element[0];
if (dimensions) element.css(dimensions);
return {
width: domElement.offsetWidth,
height: domElement.offsetHeight
};
}
/**
* Check if an event was triggered by an input element
* @param e - Event object
* @returns True if event target is a form input element
*/
triggeredByInput(e) {
return /^(label|input|textarea|select)$/i.test(e.target.tagName);
}
/**
* Apply inline styles from kendo data attributes to elements
* @param element - Container element to search within
* @param styleProps - Array of CSS property names to apply
*/
applyStylesFromKendoAttributes(element, styleProps) {
const selector = styleProps.map((styleProp) => `[${this.attr(`style-${styleProp}`)}]`).join(",");
element.find(selector).addBack(selector).each((_, currentElement) => {
const $currentElement = $(currentElement);
styleProps.forEach((styleProp) => {
const kendoAttr = this.attr(`style-${styleProp}`);
if ($currentElement.attr(kendoAttr)) {
$currentElement.css(styleProp, $currentElement.attr(kendoAttr));
$currentElement.removeAttr(kendoAttr);
}
});
});
}
/**
* Show or hide a loading mask on a container element
* @param container - Container element for the mask
* @param toggle - Whether to show (true) or hide (false) the mask
* @param options - Optional configuration for the mask
*/
progress(container, toggle, options) {
let mask = container.find(".k-loading-mask");
const browser = supportService.browser;
const opts = $.extend({}, {
width: "100%",
height: "100%",
top: container.scrollTop(),
opacity: false
}, options);
const cssClass = opts.opacity ? "k-loading-mask k-opaque" : "k-loading-mask";
if (toggle) {
if (!mask.length) {
const isRtl = supportService.isRtl(container);
const leftRight = isRtl ? "right" : "left";
const containerScrollLeft = this.scrollLeft(container);
let webkitCorrection = 0;
if (browser.webkit && isRtl) webkitCorrection = container[0].scrollWidth - (container.width() || 0) - 2 * containerScrollLeft;
const loadingText = window.kendo.ui?.progress?.messages?.loading || "Loading...";
$(`<div class='${cssClass}'><span role='alert' aria-live='polite' class='k-loading-text'>${loadingText}</span><div class='k-loading-image'></div><div class='k-loading-color'></div></div>`).width(opts.width).height(opts.height).css("top", opts.top).css(leftRight, Math.abs(containerScrollLeft) + webkitCorrection).prependTo(container);
}
} else if (mask) mask.remove();
}
/**
* Get the actual target element from an event, handling touch events.
* For touch events, uses document.elementFromPoint with touch coordinates.
* @param e - Event object (mouse or touch)
* @returns The target element
*/
eventTarget(e) {
if (!supportService.touch) return e.target;
const touches = e.originalEvent?.changedTouches || e.changedTouches;
if (touches && touches.length > 0) return document.elementFromPoint(touches[0].clientX, touches[0].clientY);
return e.target;
}
/**
* Create a drag-to-scroll handler for horizontal scrolling via mouse/touch drag.
* Encapsulates the drag state and event handling for scrollable containers.
* @param scrollContainer - The element that will be scrolled (or parent for delegation)
* @param options - Configuration options including namespace, capture element, and delegate selector
* @returns Handler with attach() and destroy() methods
*/
createDragToScrollHandler(scrollContainer, options) {
return new DragToScrollHandlerImpl(scrollContainer, options);
}
/**
* Create a ResizeObserver service for monitoring element resize events.
* Provides debounced resize callbacks and automatic cleanup.
* @param options - Configuration options including element, callback, and debounce time
* @returns ResizeObserverService instance with destroy() method
*/
createResizeObserver(options) {
return new ResizeObserverService(options);
}
};
var DragToScrollHandlerImpl = class DragToScrollHandlerImpl {
static {
this.DRAG_THRESHOLD = 5;
}
constructor(scrollContainer, options) {
this.isDragging = false;
this.hasDragged = false;
this.dragStartX = 0;
this.scrollStartLeft = 0;
this.currentDragTarget = null;
this.scrollContainer = scrollContainer;
this.namespace = options.namespace;
this.captureElement = options.captureElement;
this.delegateSelector = options.delegateSelector;
this.onDragStart = this.onDragStart.bind(this);
this.onDragMove = this.onDragMove.bind(this);
this.onDragEnd = this.onDragEnd.bind(this);
this.preventClickOnce = this.preventClickOnce.bind(this);
}
attach() {
if (!this.captureElement) return;
if (this.delegateSelector) this.scrollContainer.on("mousedown" + this.namespace, this.delegateSelector, this.onDragStart).on("touchstart" + this.namespace, this.delegateSelector, this.onDragStart);
else this.scrollContainer.on("mousedown" + this.namespace, this.onDragStart).on("touchstart" + this.namespace, this.onDragStart);
this.bindCaptureEvents();
}
destroy() {
this.scrollContainer.off(this.namespace);
if (this.captureElement) this.unbindCaptureEvents();
this.scrollContainer[0].removeEventListener("click", this.preventClickOnce, true);
}
getClientX(e) {
if (e.type.indexOf("touch") !== -1) {
const touch = e.originalEvent?.touches?.[0] || e.originalEvent?.changedTouches?.[0];
return touch ? touch.clientX : 0;
}
return e.clientX || e.originalEvent?.clientX || 0;
}
preventClickOnce(e) {
e.preventDefault();
e.stopPropagation();
e.stopImmediatePropagation();
this.scrollContainer[0].removeEventListener("click", this.preventClickOnce, true);
}
onDragStart(e) {
const target = $(e.currentTarget);
if (!target.length) return;
this.isDragging = true;
this.hasDragged = false;
this.currentDragTarget = target[0];
this.dragStartX = this.getClientX(e);
this.scrollStartLeft = target[0].scrollLeft;
target.css("cursor", "grabbing");
target.css("user-select", "none");
}
onDragMove(e) {
if (!this.isDragging || !this.currentDragTarget) return;
const clientX = this.getClientX(e);
const deltaX = this.dragStartX - clientX;
if (!this.hasDragged && Math.abs(deltaX) >= DragToScrollHandlerImpl.DRAG_THRESHOLD) this.hasDragged = true;
if (this.hasDragged) {
e.preventDefault();
this.currentDragTarget.scrollLeft = this.scrollStartLeft + deltaX;
}
}
onDragEnd() {
if (!this.isDragging) return;
if (this.currentDragTarget) {
const target = $(this.currentDragTarget);
target.css("cursor", "");
target.css("user-select", "");
}
if (this.hasDragged) this.scrollContainer[0].addEventListener("click", this.preventClickOnce, true);
this.isDragging = false;
this.hasDragged = false;
this.currentDragTarget = null;
}
bindCaptureEvents() {
if (!this.captureElement) return;
$(document).on("mousemove" + this.namespace, this.onDragMove).on("touchmove" + this.namespace, this.onDragMove).on("mouseup" + this.namespace, this.onDragEnd).on("touchend" + this.namespace, this.onDragEnd);
}
unbindCaptureEvents() {
$(document).off(this.namespace);
}
};
const DEFAULT_RESIZE_EVENT_TIME = 50;
const HAS_OBSERVER = typeof ResizeObserver !== "undefined";
/**
* @hidden
*/
var ResizeObserverService = class {
static supported() {
return HAS_OBSERVER;
}
constructor(options) {
this.onResize = (_entries) => {
if (this.resizeCallback) this.resizeCallback();
};
const el = options.element;
this.element = el instanceof $ ? el[0] : el;
this.resizeCallback = options.onResize;
this.debounceTime = options.debounceTime ?? DEFAULT_RESIZE_EVENT_TIME;
this.observeOptions = options.observeOptions || {};
this.resizeObserver = null;
this.debounceResize = null;
this.initResizeObserver();
}
initResizeObserver() {
this.debounceResize = utilsService.throttle(this.onResize.bind(this), this.debounceTime);
if (HAS_OBSERVER) {
this.resizeObserver = new ResizeObserver(this.debounceResize);
this.resizeObserver.observe(this.element, this.observeOptions);
}
}
destroy() {
this.destroyResizeObserver();
this.element = null;
}
destroyResizeObserver() {
if (this.resizeObserver) this.resizeObserver.disconnect();
if (this.debounceResize) this.debounceResize.cancel();
this.resizeObserver = null;
this.debounceResize = null;
this.resizeCallback = null;
}
};
const domUtilsService = new DomUtilsService();
//#endregion
//#region ../src/core/services/css-properties.service.ts
const PREFIX = "prefix";
/**
* Service for managing CSS class properties for widgets
*/
var CssPropertiesService = class {
constructor() {
this.themeColorValues = [
"base",
"primary",
"secondary",
"tertiary",
"inherit",
"info",
"success",
"warning",
"error",
"inverse"
];
this.fillModeValues = [
"solid",
"outline",
"flat"
];
this.shapeValues = ["rectangle", "square"];
this.sizeValues = [
["xsmall", "xs"],
["small", "sm"],
["medium", "md"],
["large", "lg"]
];
this.roundedValues = [
["small", "sm"],
["medium", "md"],
["large", "lg"],
["full", "full"],
["none", "none"]
];
this.positionModeValues = [
"fixed",
"static",
"sticky",
"absolute"
];
this.resizeValues = [
["both", "resize"],
["horizontal", "resize-x"],
["vertical", "resize-y"]
];
this.overflowValues = [
"auto",
"hidden",
"visible",
"scroll",
"clip"
];
this.layoutFlowValues = [["vertical", "!k-flex-col"], ["horizontal", "!k-flex-row"]];
this.defaultValues = {};
this.propertyDictionary = {};
this.propertyToCssClassMap = {};
this.registerDefaultCssClasses("themeColor", this.themeColorValues);
this.registerDefaultCssClasses("fillMode", this.fillModeValues);
this.registerDefaultCssClasses("shape", this.shapeValues);
this.registerDefaultCssClasses("size", this.sizeValues);
this.registerDefaultCssClasses("positionMode", this.positionModeValues);
this.registerDefaultCssClasses("rounded", this.roundedValues);
this.registerDefaultCssClasses("resize", this.resizeValues);
this.registerDefaultCssClasses("overflow", this.overflowValues);
this.registerDefaultCssClasses("layoutFlow", this.layoutFlowValues);
this.registerCssClasses("themeColor", this.themeColorValues);
this.registerCssClasses("fill", this.fillModeValues);
this.registerCssClasses("shape", this.shapeValues);
this.registerCssClasses("size", this.sizeValues);
this.registerCssClasses("positionMode", this.positionModeValues);
}
/**
* Register a CSS prefix for a widget
*/
registerPrefix(widget, prefix) {
if (!this.propertyDictionary[widget]) this.propertyDictionary[widget] = {};
this.propertyDictionary[widget][PREFIX] = prefix;
}
/**
* Register CSS values for a widget
*/
registerValues(widget, args) {
let i;
let j;
let prop;
let values;
let newValues;
let currentValue;
if (!this.propertyDictionary[widget]) this.propertyDictionary[widget] = {};
for (i = 0; i < args.length; i++) {
prop = args[i].prop;
newValues = args[i].values;
if (!this.propertyDictionary[widget][prop]) this.propertyDictionary[widget][prop] = {};
values = this.propertyDictionary[widget][prop];
for (j = 0; j < newValues.length; j++) {
currentValue = newValues[j];
if (Array.isArray(currentValue)) values[currentValue[0]] = currentValue[1];
else values[currentValue] = currentValue;
}
}
}
/**
* Get a valid CSS class for a widget property
*/
getValidClass(args) {
const widget = args.widget;
const propName = args.propName;
const value = args.value;
const overridePrefix = args.prefix;
const defaultVals = this.defaultValues[propName];
const widgetProperties = this.propertyDictionary[widget];
if (!widgetProperties) return "";
const widgetValues = widgetProperties[propName];
const validValue = widgetValues ? widgetValues[value] : defaultVals && defaultVals[value];
if (validValue) {
let prefix;
if (propName === "themeColor") prefix = widgetProperties[PREFIX];
else if (propName === "positionMode") prefix = "k-pos-";
else if (propName === "rounded") prefix = "k-rounded-";
else if (propName === "resize") prefix = "k-";
else if (propName === "overflow") prefix = "k-overflow-";
else if (propName === "layoutFlow") prefix = "";
else prefix = widgetProperties[PREFIX];
prefix = overridePrefix || prefix;
return prefix + validValue;
} else return "";
}
/**
* Register a single CSS class (internal for defaultValues)
*/
registerDefaultCssClass(propName, value, shorthand) {
if (!this.defaultValues[propName]) this.defaultValues[propName] = {};
this.defaultValues[propName][value] = shorthand || value;
}
/**
* Register multiple CSS classes for a property (internal for defaultValues)
*/
registerDefaultCssClasses(propName, arr) {
for (let i = 0; i < arr.length; i++) if (Array.isArray(arr[i])) {
const tuple = arr[i];
this.registerDefaultCssClass(propName, tuple[0], tuple[1]);
} else this.registerDefaultCssClass(propName, arr[i]);
}
/**
* Register a single legacy CSS class
*/
registerCssClass(propName, value, shorthand) {
if (!this.propertyToCssClassMap[propName]) this.propertyToCssClassMap[propName] = {};
this.propertyToCssClassMap[propName][value] = shorthand || value;
}
/**
* Register multiple legacy CSS classes
*/
registerCssClasses(propName, arr) {
for (let i = 0; i < arr.length; i++) if (Array.isArray(arr[i])) {
const tuple = arr[i];
this.registerCssClass(propName, tuple[0], tuple[1]);
} else this.registerCssClass(propName, arr[i]);
}
/**
* Get a valid legacy CSS class
*/
getValidCssClass(prefix, propName, value) {
if (value === void 0) return "";
const validValue = this.propertyToCssClassMap[propName]?.[value];
if (validValue) return prefix + validValue;
}
};
const cssPropertiesService = new CssPropertiesService();
//#endregion
//#region ../src/core/services/icon-override.service.ts
var IconService = class {
constructor() {
this.overrides = {};
this._hasOverrides = false;
this.registry = /* @__PURE__ */ new WeakMap();
this._tokenCounter = 0;
this._activeContexts = /* @__PURE__ */ new Map();
this._contextOrder = [];
}
setIcons(dictionary) {
const keys = Object.keys(dictionary);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
const value = dictionary[key];
if (typeof value === "string" || this.isSVGIcon(value)) this.overrides[key] = value;
else if (typeof value === "object" && value !== null) {
if (!this.overrides[key] || this.isSVGIcon(this.overrides[key]) || typeof this.overrides[key] === "string") this.overrides[key] = {};
const iconNames = Object.keys(value);
for (let j = 0; j < iconNames.length; j++) this.overrides[key][iconNames[j]] = value[iconNames[j]];
}
}
this._hasOverrides = true;
}
beginInit(componentName, element) {
const token = ++this._tokenCounter;
this._activeContexts.set(token, componentName);
this._contextOrder.push(token);
if (element) this.registerElement(element, componentName);
return token;
}
registerElement(element, componentName) {
const rootToken = this._contextOrder.length > 0 ? this._contextOrder[0] : null;
const rootName = rootToken !== null ? this._activeContexts.get(rootToken) : componentName;
this.registry.set(element, {
root: rootName,
self: componentName
});
}
finalizeContext(token) {
this._activeContexts.delete(token);
const idx = this._contextOrder.indexOf(token);
if (idx !== -1) this._contextOrder.splice(idx, 1);
}
resolve(iconName, context) {
if (!this._hasOverrides) return null;
let names;
if (this._contextOrder.length > 0) {
names = [];
for (let i = 0; i < this._contextOrder.length; i++) names.push(this._activeContexts.get(this._contextOrder[i]));
} else if (context) {
const ctx = this.registry.get(context) || this._findAncestorContext(context);
if (ctx) names = ctx.root !== ctx.self ? [ctx.root, ctx.self] : [ctx.root];
}
if (names) for (let i = 0; i < names.length; i++) {
const ov = this.overrides[names[i]];
if (ov && !this.isSVGIcon(ov) && typeof ov !== "string") {
const icon = ov[iconName];
if (icon) return icon;
}
}
const globalOv = this.overrides[iconName];
if (globalOv && (this.isSVGIcon(globalOv) || typeof globalOv === "string")) return globalOv;
return null;
}
reset() {
this.overrides = {};
this._hasOverrides = false;
this._activeContexts.clear();
this._contextOrder = [];
this._tokenCounter = 0;
}
_findAncestorContext(element) {
let current = element.parentElement;
while (current) {
const ctx = this.registry.get(current);
if (ctx) return ctx;
current = current.parentElement;
}
}
isSVGIcon(value) {
return typeof value === "object" && value !== null && "name" in value && "viewBox" in value && "content" in value;
}
};
const iconService = new IconService();
//#endregion
//#region ../src/licensing/index.ts
let _parsedPackageMetadata = null;
try {
_parsedPackageMetadata = Object.freeze(JSON.parse("{\"productName\":\"Kendo UI\",\"productCode\":\"KENDOUICOMPLETE\",\"redistributedBy\":[\"KENDOUI\",\"UIASPCORE\",\"KENDOMVC\",\"KENDOUIMVC\"],\"licensingDocsUrl\":\"https://www.telerik.com/kendo-jquery-ui/documentation/intro/installation/licensing/activation-errors-and-warnings\",\"name\":\"@progress/kendo-ui\",\"version\":\"2026.3.812\",\"publishDate\":1786524915,\"productCodes\":[\"KENDOUICOMPLETE\",\"KENDOUI\",\"UIASPCORE\",\"KENDOMVC\",\"KENDOUIMVC\"]}"));
} catch {
_parsedPackageMetadata = Object.freeze({
name: "@progress/kendo-ui",
productName: "Kendo UI for jQuery",
productCode: "KENDOUICOMPLETE",
productCodes: [
"KENDOUICOMPLETE",
"KENDOUI",
"UIASPCORE",
"KENDOMVC",
"KENDOUIMVC"
],
redistributedBy: [
"KENDOUI",
"UIASPCORE",
"KENDOMVC",
"KENDOUIMVC"
],
publishDate: 0,
version: "0.0.0",
licensingDocsUrl: "https://www.telerik.com/kendo-jquery-ui/documentation/intro/installation/licensing/activation-errors-and-warnings"
});
}
const TRUSTED_HOSTS = [
/telerik\.com/,
/progress\.com/,
/stackblitz\.io/,
/csb\.app/,
/telerik\.io/
];
const BANNER_FONT_FAMILY = "system-ui, -apple-system, \"Segoe UI\", Roboto, Helvetica, Arial, \"Noto Sans\", \"Liberation Sans\", sans-serif";
function applyStyles(el, styles) {
Object.keys(styles).forEach((k) => el.style.setProperty(k, styles[k]));
}
function sanitizeSvg(svg) {
return svg.replace(/\bfillRule\b/g, "fill-rule").replace(/\bclipRule\b/g, "clip-rule").replace(/\bstrokeWidth\b/g, "stroke-width").replace(/\bstrokeDasharray\b/g, "stroke-dasharray").replace(/\bstrokeLinecap\b/g, "stroke-linecap").replace(/\bstrokeLinejoin\b/g, "stroke-linejoin");
}
function addWatermarkOverlay(el) {
const watermark = document.createElement("div");
applyStyles(watermark, {
"position": "absolute",
"width": "100%",
"height": "100%",
"pointer-events": "none",
"top": "0",
"left": "0",
"right": "0",
"bottom": "0"
});
const watermarkRoot = watermark.attachShadow({ mode: "closed" });
const watermarkElement = document.createElement("div");
applyStyles(watermarkElement, {
"position": "absolute",
"top": "0",
"left": "0",
"right": "0",
"bottom": "0",
"pointer-events": "none",
"z-index": "101",
"opacity": "0.12",
"width": "100%",
"height": "100%",
"background-image": "url('data:image/png;base64,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')"
});
watermarkRoot.appendChild(watermarkElement);
el.appendChild(watermark);
new MutationObserver(function(e) {
const record = e[0];
if (record.removedNodes && Array.from(record.removedNodes).indexOf(watermark) > -1) setTimeout(() => {
el.appendChild(watermark);
}, 100);
if (record.type === "attributes" && record.target === watermark) setTimeout(() => {
watermark.removeAttribute(record.attributeName);
}, 100);
}).observe(el, {
childList: true,
attributes: true,
subtree: true
});
}
function createBannerElement(licenseMessage) {
const banner = document.createElement("div");
banner.setAttribute("id", "k-license-banner");
const iconSvg = sanitizeSvg(licenseMessage.notificationIcon.content || "");
let bodyHTML = licenseMessage.notificationBody || "";
const titleText = licenseMessage.notificationTitle || "";
if (titleText && bodyHTML.startsWith(titleText)) bodyHTML = bodyHTML.slice(titleText.length).trim();
const ctaHTML = licenseMessage.callToAction ? `<a id="k-license-cta" href="${licenseMessage.callToAction.link}" target="_blank" rel="noopener noreferrer">${licenseMessage.callToAction.message}</a>` : "";
banner.innerHTML = `
<span id="k-license-icon">${iconSvg}</span>
<div id="k-license-content">
<div id="k-license-title">${titleText}</div>
<div id="k-license-body">${bodyHTML}</div>
</div>
<div id="k-license-actions">
${ctaHTML}
<button id="k-license-close" title="Close">
<svg width="20" height="20" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M11.9309 3.1838C12.1754 2.93933 12.5712 2.93937 12.8157 3.1838C13.0601 3.4283 13.0601 3.82407 12.8157 4.06857L8.885 7.99923L12.8166 11.9309C13.0611 12.1754 13.0611 12.5721 12.8166 12.8166C12.5721 13.0611 12.1754 13.0611 11.9309 12.8166L7.99925 8.88497L4.06859 12.8166C3.8241 13.0611 3.42732 13.0611 3.18285 12.8166C2.93862 12.5721 2.93851 12.1753 3.18285 11.9309L7.11449 7.99923L3.18382 4.06857C2.93947 3.82413 2.93955 3.42829 3.18382 3.1838C3.42831 2.9393 3.82508 2.9393 4.06957 3.1838L7.99925 7.11349L11.9309 3.1838Z" fill="#212529"/>
</svg>
</button>
</div>
`;
applyStyles(banner, {
"display": "flex",
"position": "fixed",
"left": "50%",
"transform": "translateX(-50%)",
"width": "100%",
"border-left": "6px solid rgba(255, 192, 0, 1)",
"border-top": "1px solid #00000029",
"border-right": "1px solid #00000029",
"border-bottom": "1px solid #00000029",
"background-color": "#ffffff",
"box-shadow": "0px 4px 5px 0px #0000000A, 0px 2px 4px 0px #00000008",
"font-size": "14px",
"font-weight": "400",
"line-height": "20px",
"color": "#1E1E1E",
"justify-content": "center",
"z-index": "2000",
"box-sizing": "border-box"
});
const iconEl = banner.querySelector("#k-license-icon");
applyStyles(iconEl, {
"display": "flex",
"flex-shrink": "0"
});
const contentEl = banner.querySelector("#k-license-content");
applyStyles(contentEl, {
"display": "flex",
"flex-direction": "column",
"gap": "4px"
});
applyStyles(banner.querySelector("#k-license-title"), {
"font-family": BANNER_FONT_FAMILY,
"font-weight": "700",
"font-size": "14px",
"line-height": "142%",
"font-style": "Bold",
"letter-spacing": "0px",
"vertical-align": "middle",
"text-align": "left"
});
applyStyles(banner.querySelector("#k-license-body"), {
"font-family": BANNER_FONT_FAMILY,
"font-weight": "400",
"font-size": "14px",
"line-height": "20px",
"letter-spacing": "0px",
"vertical-align": "middle",
"text-align": "left"
});
const ctaEl = banner.querySelector("#k-license-cta");
if (ctaEl) {
applyStyles(ctaEl, {
"display": "inline-flex",
"border": "none",
"border-radius": "4px",
"background-color": "#eb0249",
"color": "#ffffff",
"padding": "4px 8px",
"white-space": "nowrap",
"text-decoration": "none",
"font-family": BANNER_FONT_FAMILY,
"cursor": "pointer",
"position": "relative",
"transition": "background-color 0.2s ease-in-out",
"outline": "none"
});
ctaEl.addEventListener("mouseenter", function() {
ctaEl.style.setProperty("background-color", "#b90138");
});
ctaEl.addEventListener("mouseleave", function() {
ctaEl.style.setProperty("background-color", "#eb0249");
});
}
const actionsEl = banner.querySelector("#k-license-actions");
applyStyles(actionsEl, {
"display": "flex",
"align-items": "center",
"gap": "16px"
});
const closeEl = banner.querySelector("#k-license-close");
applyStyles(closeEl, {
"display": "inline-flex",
"border": "none",
"border-radius": "4px",
"padding": "4px",
"background-color": "transparent",
"cursor": "pointer",
"outline": "none",
"transition": "background-color 0.2s ease-in-out"
});
closeEl.addEventListener("mouseenter", function() {
closeEl.style.setProperty("background-color", "#3d3d3d14");
});
closeEl.addEventListener("mouseleave", function() {
closeEl.style.setProperty("background-color", "transparent");
});
const mqMobile = window.matchMedia("(max-width: 499px)");
const mqTablet = window.matchMedia("(max-width: 767px)");
const applyResponsiveStyles = function() {
const isMobile = mqMobile.matches;
const isTablet = mqTablet.matches;
const isDesktop = !isTablet;
applyStyles(banner, {
"top": isMobile || isTablet ? "0" : "16px",
"max-width": isDesktop ? "768px" : "none",
"border-radius": isDesktop ? "6px" : "0",
"flex-direction": isMobile ? "column" : "row",
"align-items": isMobile ? "flex-start" : "center",
"padding": isMobile ? "12px" : "0"
});
applyStyles(iconEl, {
"align-self": isMobile ? "flex-start" : "center",
"padding": isMobile ? "0 0 12px 0" : "9px 12px"
});
applyStyles(contentEl, {
"flex": isMobile ? "none" : "1",
"padding": isMobile ? "0 0 12px 0" : "12px"
});
applyStyles(actionsEl, {
"padding": isMobile ? "0" : "9px 12px",
"margin-left": isMobile ? "0" : "auto",
"width": isMobile ? "100%" : "auto"
});
if (isMobile) applyStyles(closeEl, {
"position": "absolute",
"top": "12px",
"right": "12px"
});
else {
applyStyles(closeEl, { "position": "relative" });
closeEl.style.removeProperty("top");
closeEl.style.removeProperty("right");
}
};
applyResponsiveStyles();
mqMobile.addEventListener("change", applyResponsiveStyles);
mqTablet.addEventListener("change", applyResponsiveStyles);
closeEl.addEventListener("click", function() {
mqMobile.removeEventListener("change", applyResponsiveStyles);
mqTablet.removeEventListener("change", applyResponsiveStyles);
banner.hidden = true;
});
return banner;
}
function showBanner(licenseMessage) {
if (document.querySelector("#k-license-banner")) return;
document.body.appendChild(createBannerElement(licenseMessage));
}
function shouldHideWatermarkAndBanner() {
return TRUSTED_HOSTS.some((r) => r.test(window.location.hostname));
}
const packageMetadata = _parsedPackageMetadata;
function addWatermarkOverlayAndBanner(el) {
if (shouldHideWatermarkAndBanner()) return;
const wrappersMetadata = window._wrappersMetadata;
const { message } = (0, _progress_kendo_licensing.getLicenseStatus)(wrappersMetadata || packageMetadata);
const isValid = (0, _progress_kendo_licensing.validatePackage)(wrappersMetadata || packageMetadata);
if (!message && isValid) return;
if (message.severity !== "INFO") addWatermarkOverlay(el);
showBanner(message);
}
//#endregion
//#region ../src/core/base/widget.ts
/**
* Kendo UI Widget Class
*
* @example
* // ES6 class inheritance
* class MyWidget extends Widget {
* init(element, options) {
* super.init(element, options);
* // widget-specific initialization
* }
* }
*
* @example
* // Legacy extend pattern
* const MyWidget = Widget.extend({
* init: function(element, options) {
* Widget.fn.init.call(this, element, options);
* // widget-specific initialization
* },
* options: {
* name: "MyWidget"
* }
* });
*/
const cssPropertiesNames$1 = [
"themeColor",
"fillMode",
"shape",
"size",
"rounded",
"positionMode"
];
const ARIA_LABELLEDBY = "aria-labelledby";
const ARIA_LABEL = "aria-label";
const LABELIDPART = "_label";
/**
* Base Widget class for Kendo UI components.
*/
var Widget = class Widget extends Observable {
/**
* Static call method to support legacy pattern: Widget.call(this, element, options)
*
* ES6 classes cannot be invoked with Function.prototype.call(), but some legacy
* code uses `kendo.ui.Widget.call(this, element, options)` instead of the proper
* `Widget.fn.init.call(this, element, options)` pattern.
*
* By defining a static `call` method, we intercept these calls and route them
* to the init method, maintaining backward compatibility.
*
* @param thisArg - The context (this) to call init on
* @param element - The DOM element to bind the widget to
* @param options - Widget configuration options
*/
static call(thisArg, element, options) {
Widget.fn.init.call(thisArg, element, options);
}
/**
* Static apply method to support legacy pattern: Widget.apply(this, arguments)
*
* Similar to call(), this intercepts Function.prototype.apply() calls.
*
* @param thisArg - The context (this) to call init on
* @param args - Array of arguments [element, options]
*/
static apply(thisArg, args) {
Widget.fn.init.apply(thisArg, args);
}
/**
* Constructor - receives element and options and calls init().
* This mirrors the legacy extend() pattern where the constructor IS the init function.
*
* @param element - The DOM element to bind the widget to
* @param options - Widget configuration options
*/
constructor(element, options) {
super();
this._features = [];
this._iconContextToken = 0;
if (element !== void 0) this.init(element, options);
}
/**
* Initialize the widget
* @param element - The DOM element to bind to
* @param options - Widget configuration options
*/
init(element, options) {
const that = this;
that._showWatermarkOverlay = addWatermarkOverlayAndBanner;
const componentName = (this.options?.name || "").toLowerCase();
const kendoJQuery = kendoJQueryService.getConstructor();
that.element = kendoJQuery(element).handler(that);
if (componentName) that._iconContextToken = iconService.beginInit(componentName, that.element[0]);
Observable.fn.init.call(that);
let dataSource = options ? options.dataSource : null;
let props;
if (options) props = (that.componentTypes || {})[options.componentType];
if (dataSource) options = kendoJQuery.extend({}, options, { dataSource: {} });
const userFeatures = options?.features;
const protoFeatures = that.options?.features;
const features = userFeatures ?? protoFeatures ?? [];
if (options) delete options.features;
options = that.options = kendoJQuery.extend(true, {}, that.options, that.defaults, props || {}, options);
if (dataSource) options.dataSource = dataSource;
options.features = features;
that._features = features;
that._validateFeatures(features);
for (let i = 0; i < features.length; i++) features[i].setup(that);
const roleAttr = domUtilsService.attr("role");
if (!that.element.attr(roleAttr)) that.element.attr(roleAttr, (options.name || "").toLowerCase());
that.element.data("kendo" + options.prefix + options.name, that);
that.bind(that.events, options);
}
endInit() {
if (this._iconContextToken) {
const token = this._iconContextToken;
this._iconContextToken = 0;
iconService.finalizeContext(token);
}
}
_renderWithIconContext(fn) {
const componentName = (this.options?.name || "").toLowerCase();
if (!componentName) return fn();
const token = iconService.beginInit(componentName, this.element?.[0]);
const result = fn();
iconService.finalizeContext(token);
return result;
}
/**
* Check if the element has a MVVM binding target
* @returns true if the element has a bindingTarget
*/
_hasBindingTarget() {
return !!this.element[0].kendoBindingTarget;
}
/**
* Set up tabindex on target element
* @param target - Target element (defaults to wrapper)
*/
_tabindex(target) {
target = target || this.wrapper;
const element = this.element;
const TABINDEX = "tabindex";
const tabindex = target.attr(TABINDEX) || element.attr(TABINDEX);
element.removeAttr(TABINDEX);
target.attr(TABINDEX, !isNaN(tabindex) ? tabindex : 0);
}
/**
* Update widget options
* @param options - New options to merge
*/
setOptions(options) {
this._clearCssClasses(options);
this._setEvents(options);
kendoJQueryService.getConstructor().extend(this.options, options);
this._applyCssClasses();
}
/**
* Internal method to update event bindings when options change
* @param options - New options containing event handlers
*/
_setEvents(options) {
const that = this;
let idx = 0;
const length = that.events.length;
let e;
for (; idx < length; idx++) {
e = that.events[idx];
if (that.options[e] && options[e]) {
that.unbind(e, that.options[e]);
if (that._events && that._events[e]) delete that._events[e];
}
}
that.bind(that.events, options);
}
/**
* Handle resize events
* @param force - Force resize even if size hasn't changed
*/
resize(force) {
const size = this.getSize();
const currentSize = this._size;
if (force || (size.width > 0 || size.height > 0) && (!currentSize || size.width !== currentSize.width || size.height !== currentSize.height)) {
this._size = size;
this._resize(size, force);
this.trigger("resize", size);
}
}
/**
* Get current widget dimensions
* @returns Size object with width and height
*/
getSize() {
return domUtilsService.dimensions(this.element);
}
/**
* Get or set widget size
* @param size - Optional size to set
* @returns Current size if no argument, undefined if setting
*/
size(size) {
if (!size) return this.getSize();
else this.setSize(size);
}
/**
* Set widget size (override in subclasses)
* @param size - Size to set
*/
setSize(_size) {}
/**
* Internal resize handler (override in subclasses)
* @param size - New size
* @param force - Whether resize was forced
*/
_resize(_size, _force) {}
_validateFeatures(features) {
const featureMap = this.constructor.featureMap;
if (!featureMap) return;
const ctor = this.constructor;
const defaults = ctor.options || ctor.prototype?.options;
if (!defaults) return;
const loadedNames = {};
for (let i = 0; i < features.length; i++) loadedNames[features[i].name] = true;
for (const featureName in featureMap) {
if (loadedNames[featureName]) continue;
const opts = featureMap[featureName];
for (let i = 0; i < opts.length; i++) {
const key = opts[i];
if (this.options[key] !== void 0 && this.options[key] !== defaults[key]) throw new Error(`Option "${key}" requires the "${featureName}" feature. Import it and add it to the features array.`);
}
}
}
/**
* Destroy the widget and clean up resources
*/
destroy() {
const that = this;
if (that._features) for (let i = that._features.length - 1; i >= 0; i--) {
const f = that._features[i];
if (f.teardown) f.teardown(that);
}
that.element.removeData("kendo" + that.options.prefix + that.options.name);
that.element.removeData("handler");
that.unbind();
}
/**
* Internal destroy method
*/
_destroy() {
this.destroy();
}
/**
* Apply CSS classes based on widget options
* @param element - Optional element to apply classes to
*/
_applyCssClasses(element) {
const protoOptions = this.__proto__.options;
const options = this.options;
const el = element || this.wrapper || this.element;
const classes = [];
let i;
let prop;
let widgetName;
let widgetProperties;
const cssProps = cssPropertiesService;
widgetName = this.options._altname || protoOptions.name;
widgetProperties = cssProps.propertyDictionary[widgetName];
if (!cssProps || !widgetProperties) return;
for (i = 0; i < cssPropertiesNames$1.length; i++) {
prop = cssPropertiesNames$1[i];
widgetName = this.options._altname || protoOptions.name;
if (prop in protoOptions || prop in options) classes.push(cssProps.getValidClass({
widget: widgetName,
propName: prop,
value: options[prop]
}));
}
el.addClass(classes.join(" "));
}
/**
* Set up ARIA label for accessibility
* @param target - Target element to apply ARIA attributes to
*/
_ariaLabel(target) {
const that = this;
const inputElm = that.element;
const inputId = inputElm.attr("id");
const labelElm = kendoJQueryService.getConstructor()("label[for=\"" + inputId + "\"]");
const ariaLabel = inputElm.attr(ARIA_LABEL);
const ariaLabelledBy = inputElm.attr(ARIA_LABELLEDBY);
let labelId;
if (target[0] === inputElm[0]) return;
if (ariaLabel) target.attr(ARIA_LABEL, ariaLabel);
else if (ariaLabelledBy) target.attr(ARIA_LABELLEDBY, ariaLabelledBy);
else if (labelElm.length) {
const guid = utilsService.guid();
labelId = labelElm.attr("id") || that._generateLabelId(labelElm, inputId || guid);
target.attr(ARIA_LABELLEDBY, labelId);
}
}
/**
* Clear CSS classes before updating options
* @param newOptions - New options being applied
* @param element - Optional element to clear classes from
*/
_clearCssClasses(newOptions, element) {
const protoOptions = this.__proto__.options;
const currentOptions = this.options;
const el = element || this.wrapper || this.element;
let i;
let prop;
let widgetName;
let widgetProperties;
const cssProps = cssPropertiesService;
widgetName = this.options._altname || protoOptions.name;
widgetProperties = cssProps.propertyDictionary[widgetName];
if (!cssProps || !widgetProperties) return;
for (i = 0; i < cssPropertiesNames$1.length; i++) {
prop = cssPropertiesNames$1[i];
if ((prop in protoOptions || prop in currentOptions) && newOptions.hasOwnProperty(prop)) if (prop === "themeColor") el.removeClass(cssProps.getValidClass({
widget: widgetName,
propName: prop,
value: currentOptions[prop],
fill: currentOptions.fillMode
}));
else {
if (prop === "fillMode") el.removeClass(cssProps.getValidClass({
widget: widgetName,
propName: "themeColor",
value: currentOptions.themeColor,
fill: currentOptions.fillMode
}));
el.removeClass(cssProps.getValidClass({
widget: widgetName,
propName: prop,
value: currentOptions[prop]
}));
}
}
}
/**
* Generate a unique label ID for ARIA
* @param label - Label element
* @param inputId - Input element ID
* @returns Generated label ID
*/
_generateLabelId(label, inputId) {
const labelId = inputId + LABELIDPART;
label.attr("id", labelId);
return labelId;
}
};
Widget.fn = Widget.prototype;
Widget.prototype.options = { prefix: "" };
Widget.prototype.events = [];
//#endregion
//#region ../src/core/base/databound-widget.ts
var DataBoundWidget = class extends Widget {
/**
* Retrieves the data items currently bound to the widget.
* @returns An array of data items
*/
dataItems() {
const dataSource = this.dataSource;
if (dataSource && typeof dataSource.view === "function") return dataSource.flatView();
return [];
}
};
DataBoundWidget.fn = DataBoundWidget.prototype;
//#endregion
//#region ../src/core/services/culture.service.ts
const DEFAULT_LANGUAGE = "en-US";
const DEFAULT_EN_US_CULTURE = {
name: DEFAULT_LANGUAGE,
numberFormat: {
pattern: ["-n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3],
percent: {
pattern: ["-n %", "n %"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3],
symbol: "%"
},
currency: {
name: "US Dollar",
abbr: "USD",
pattern: ["($n)", "$n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3],
symbol: "$"
}
},
calendars: { standard: {
days: {
names: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
],
namesAbbr: [
"Sun",
"Mon",
"Tue",
"Wed",
"Thu",
"Fri",
"Sat"
],
namesShort: [
"Su",
"Mo",
"Tu",
"We",
"Th",
"Fr",
"Sa"
]
},
months: {
names: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
],
namesAbbr: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
]
},
AM: [
"AM",
"am",
"AM"
],
PM: [
"PM",
"pm",
"PM"
],
patterns: {
d: "M/d/yyyy",
D: "dddd, MMMM dd, yyyy",
F: "dddd, MMMM dd, yyyy h:mm:ss tt",
g: "M/d/yyyy h:mm tt",
G: "M/d/yyyy h:mm:ss tt",
m: "MMMM dd",
M: "MMMM dd",
s: "yyyy'-'MM'-'ddTHH':'mm':'ss",
t: "h:mm tt",
T: "h:mm:ss tt",
u: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
y: "MMMM, yyyy",
Y: "MMMM, yyyy"
},
"/": "/",
":": ":",
firstDay: 0,
twoDigitYearMax: 2029
} }
};
var CultureService = class {
constructor() {
if (!window.kendo) window.kendo = {};
if (!window.kendo.cultures) window.kendo.cultures = {};
this.cultures = window.kendo.cultures;
if (!this.cultures[DEFAULT_LANGUAGE]) this.cultures[DEFAULT_LANGUAGE] = DEFAULT_EN_US_CULTURE;
}
/**
* Finds a culture by name or returns the culture object if already in the correct format
* @param {string|Culture} culture - Culture name (e.g., "en-US") or culture object
* @returns {Culture|null} The found culture object or null
*/
findCulture(culture) {
if (culture) {
if (typeof culture === "string") return this.cultures[culture] || this.cultures[culture.split("-")[0]] || null;
if (culture.numberFormat) return culture;
return null;
}
return null;
}
/**
* Gets a culture by name, returning current culture if not found
* @param {string|Culture} culture - Culture name or culture object
* @returns {Culture} The found culture or current culture
*/
getCulture(culture) {
if (culture) culture = this.findCulture(culture);
return culture || this.cultures.current;
}
/**
* Appends AM/PM designators to the culture's AM/PM arrays
* @param {Calendars} calendars - The calendars object from a culture
*/
appendDesignatorsToCultures(calendars) {
if (calendars.standard.AM && calendars.standard.AM.length && calendars.standard.PM && calendars.standard.PM.length && calendars.standard.AM.indexOf("PMA0") < 0 && (calendars.standard.AM.indexOf("AM") > -1 || calendars.standard.PM.indexOf("PM") > -1)) {
calendars.standard.AM.push("a", "A", "PMa", "PMA", "PMa0", "PMA0");
calendars.standard.PM.push("p", "P", "AMp", "AMP", "AMp0", "AMP0");
}
}
/**
* Gets the current culture
* @returns {Culture} The current culture
*/
culture() {
this.appendDesignatorsToCultures(this.cultures.current.calendars);
return this.cultures.current;
}
/**
* Sets the current culture
* @param {string} cultureName - The name of the culture to set
*/
setCulture(cultureName) {
const culture = this.findCulture(cultureName) || this.cultures[DEFAULT_LANGUAGE];
culture.calendar = culture.calendars.standard;
this.cultures.current = culture;
}
/**
* Register a culture (called when external culture files are loaded)
* @param {string} name - Culture name (e.g., "de-DE")
* @param {Culture} culture - Culture object
*/
registerCulture(name, culture) {
this.cultures[name] = culture;
}
/**
* Get the cultures registry (for creating proxy)
* @returns {CulturesRegistry} The cultures registry
*/
getCulturesRegistry() {
return this.cultures;
}
};
const cultureService = new CultureService();
//#endregion
//#region ../src/core/services/number-formatter.service.ts
const DOT$1 = ".";
const COMMA$1 = ",";
const SHARP = "#";
const ZERO = "0";
const PLACEHOLDER = "??";
const EMPTY = "";
const STANDARD_FORMAT_REGEX = /^(n|c|p|e)(\d*)$/i;
const LITERAL_REGEX = /(\\.)|(googol)|(['][^']*[']?)|(["][^"]*["]?)/g;
const COMMA_REGEX = /\,/g;
const numberFormatterService = new class NumberFormatterService {
format(number, format, culture) {
const resolvedCulture = culture ? cultureService.getCulture(culture) : cultureService.culture();
let numberFormat = resolvedCulture.numberFormat;
let decimal = numberFormat[DOT$1];
let precision = numberFormat.decimals;
let pattern = numberFormat.pattern[0];
const literals = [];
let symbol;
let isCurrency;
let isPercent;
let customPrecision;
let formatAndPrecision;
let negative = number < 0;
let integer;
let fraction;
let integerLength;
let value = EMPTY;
let length;
let hasGroup;
let hasNegativeFormat;
let decimalIndex;
let zeroIndex;
let start = -1;
let end;
if (number === void 0) return EMPTY;
if (!isFinite(number)) return String(number);
if (!format) return resolvedCulture.name.length ? number.toLocaleString() : number.toString();
formatAndPrecision = STANDARD_FORMAT_REGEX.exec(format);
if (formatAndPrecision) {
format = formatAndPrecision[1].toLowerCase();
isCurrency = format === "c";
isPercent = format === "p";
if (isCurrency || isPercent) {
numberFormat = isCurrency ? numberFormat.currency : numberFormat.percent;
decimal = numberFormat[DOT$1];
precision = numberFormat.decimals;
symbol = numberFormat.symbol;
pattern = numberFormat.pattern[negative ? 0 : 1];
}
customPrecision = formatAndPrecision[2];
if (customPrecision) precision = +customPrecision;
if (format === "e") return (customPrecision ? number.toExponential(precision) : number.toExponential()).replace(DOT$1, numberFormat[DOT$1]);
if (isPercent) number *= 100;
const rounded = this.round(number, precision);
negative = parseFloat(rounded) < 0;
const parts = rounded.split(DOT$1);
integer = parts[0];
fraction = parts[1];
if (negative) integer = integer.substring(1);
value = this.groupInteger(integer, 0, integer.length, numberFormat);
if (fraction) value += decimal + fraction;
if (format === "n" && !negative) return value;
let result = EMPTY;
for (let idx = 0, len = pattern.length; idx < len; idx++) {
const ch = pattern.charAt(idx);
if (ch === "n") result += value;
else if (ch === "$" || ch === "%") result += symbol;
else result += ch;
}
return result;
}
format = this.extractLiterals(format, literals);
const formatSections = format.split(";");
const formatSectionResult = this.selectFormatSection(formatSections, negative, number);
format = formatSectionResult.format;
hasNegativeFormat = formatSectionResult.hasNegativeFormat;
if (formatSectionResult.isZeroFormat) return format;
let percentIndex = format.indexOf("%");
let currencyIndex = format.indexOf("$");
isPercent = percentIndex !== -1;
isCurrency = currencyIndex !== -1;
if (isPercent) number *= 100;
if (isCurrency && format[currencyIndex - 1] === "\\") {
format = format.split("\\").join("");
isCurrency = false;
}
if (isCurrency || isPercent) {
numberFormat = isCurrency ? numberFormat.currency : numberFormat.percent;
decimal = numberFormat[DOT$1];
precision = numberFormat.decimals;
symbol = numberFormat.symbol;
}
hasGroup = format.indexOf(COMMA$1) > -1;
if (hasGroup) format = format.replace(COMMA_REGEX, EMPTY);
const decimalResult = this.calculateDecimalPrecision(format, number, negative);
format = decimalResult.format;
decimalIndex = decimalResult.decimalIndex;
length = decimalResult.length;
const roundedNumber = decimalResult.number;
const positionResult = this.findPlaceholderPositions(format);
start = positionResult.start;
end = positionResult.end;
zeroIndex = positionResult.zeroIndex;
if (start === length) end = start;
if (start !== -1) {
const valueParts = roundedNumber.toString().split(DOT$1);
integer = valueParts[0];
fraction = valueParts[1] || EMPTY;
integerLength = integer.length;
if (negative && parseFloat(roundedNumber) * -1 >= 0) negative = false;
let result = this.applyPatternToNumber(format, start, end, length, negative, hasNegativeFormat, decimalIndex, integer, fraction, decimal, zeroIndex);
if (hasGroup) result = this.groupInteger(result, start + (negative && !hasNegativeFormat ? 1 : 0), Math.max(end, integerLength + start), numberFormat);
if (end >= start) result += format.substring(end + 1);
if (isCurrency || isPercent) result = this.replaceSymbols(result, symbol);
if (literals.length) result = this.replaceLiterals(result, literals);
return result;
}
return String(roundedNumber);
}
replaceSymbols(number, symbol) {
let value = EMPTY;
for (let idx = 0, len = number.length; idx < len; idx++) {
const ch = number.charAt(idx);
value += ch === "$" || ch === "%" ? symbol : ch;
}
return value;
}
replaceLiterals(number, literals) {
for (let idx = 0; idx < literals.length; idx++) number = number.replace(PLACEHOLDER, literals[idx]);
return number;
}
applyPatternToNumber(format, start, end, length, negative, hasNegativeFormat, decimalIndex, integer, fraction, decimal, zeroIndex) {
let number = format.substring(0, start);
let replacement = EMPTY;
const integerLength = integer.length;
if (negative && !hasNegativeFormat) number += "-";
let idx = start;
while (idx < length) {
const ch = format.charAt(idx);
if (decimalIndex === -1) {
if (end - idx < integerLength) {
number += integer;
break;
}
} else {
if (zeroIndex !== -1 && zeroIndex < idx) replacement = EMPTY;
if (decimalIndex - idx <= integerLength && decimalIndex - idx > -1) {
number += integer;
idx = decimalIndex;
}
if (decimalIndex === idx) {
number += (fraction ? decimal : EMPTY) + fraction;
idx += end - decimalIndex + 1;
continue;
}
}
if (ch === ZERO) {
number += ch;
replacement = ch;
} else if (ch === SHARP) number += replacement;
idx++;
}
return number;
}
selectFormatSection(formatSections, negative, number) {
let format;
let hasNegativeFormat = false;
let isZeroFormat = false;
if (negative && formatSections[1]) {
format = formatSections[1];
hasNegativeFormat = true;
} else if (number === 0 && formatSections[2]) {
format = formatSections[2];
if (format.indexOf(SHARP) === -1 && format.indexOf(ZERO) === -1) isZeroFormat = true;
} else format = formatSections[0];
return {
format,
hasNegativeFormat,
isZeroFormat
};
}
calculateDecimalPrecision(format, number, negative) {
let decimalIndex = format.indexOf(DOT$1);
let idx = 0;
let length = format.length;
let fraction;
let zeroIndex;
let sharpIndex;
let hasZero;
let hasSharp;
let rounded;
if (decimalIndex !== -1) {
const expParts = number.toString().split("e");
if (expParts[1]) fraction = this.round(number, Math.abs(parseInt(expParts[1], 10)));
else fraction = expParts[0];
fraction = fraction.split(DOT$1)[1] || EMPTY;
zeroIndex = format.lastIndexOf(ZERO) - decimalIndex;
sharpIndex = format.lastIndexOf(SHARP) - decimalIndex;
hasZero = zeroIndex > -1;
hasSharp = sharpIndex > -1;
idx = fraction.length;
if (!hasZero && !hasSharp) {
format = format.substring(0, decimalIndex) + format.substring(decimalIndex + 1);
length = format.length;
decimalIndex = -1;
idx = 0;
}
if (hasZero && zeroIndex > sharpIndex) idx = zeroIndex;
else if (sharpIndex > zeroIndex) {
if (hasSharp && idx > sharpIndex) {
rounded = this.round(number, sharpIndex, negative);
while (rounded.charAt(rounded.length - 1) === ZERO && sharpIndex > 0 && sharpIndex > zeroIndex) {
sharpIndex--;
rounded = this.round(number, sharpIndex, negative);
}
idx = sharpIndex;
} else if (hasZero && idx < zeroIndex) idx = zeroIndex;
}
}
const resultNumber = this.round(number, idx, negative);
return {
format,
decimalIndex,
length,
number: resultNumber
};
}
findPlaceholderPositions(format) {
let sharpIndex = format.indexOf(SHARP);
const startZeroIndex = format.indexOf(ZERO);
let start;
let end;
let zeroIndex;
if (sharpIndex === -1 && startZeroIndex !== -1) start = startZeroIndex;
else if (sharpIndex !== -1 && startZeroIndex === -1) start = sharpIndex;
else start = sharpIndex > startZeroIndex ? startZeroIndex : sharpIndex;
sharpIndex = format.lastIndexOf(SHARP);
zeroIndex = format.lastIndexOf(ZERO);
if (sharpIndex === -1 && zeroIndex !== -1) end = zeroIndex;
else if (sharpIndex !== -1 && zeroIndex === -1) end = sharpIndex;
else end = sharpIndex > zeroIndex ? sharpIndex : zeroIndex;
return {
start,
end,
zeroIndex
};
}
extractLiterals(format, literals) {
if (format.indexOf("'") > -1 || format.indexOf("\"") > -1 || format.indexOf("\\") > -1) format = format.replace(LITERAL_REGEX, (match) => {
const quoteChar = match.charAt(0).replace("\\", "");
const literal = match.slice(1).replace(quoteChar, "");
literals.push(literal);
return PLACEHOLDER;
});
return format;
}
groupInteger(number, start, end, numberFormat) {
const decimalIndex = number.indexOf(numberFormat[DOT$1]);
const groupSizes = numberFormat.groupSize.slice();
let groupSize = groupSizes.shift();
let integer;
let integerLength;
let idx;
let parts;
let value;
let newGroupSize;
end = decimalIndex !== -1 ? decimalIndex : end + 1;
integer = number.substring(start, end);
integerLength = integer.length;
if (integerLength >= groupSize) {
idx = integerLength;
parts = [];
while (idx > -1) {
value = integer.substring(idx - groupSize, idx);
if (value) parts.push(value);
idx -= groupSize;
newGroupSize = groupSizes.shift();
groupSize = newGroupSize !== void 0 ? newGroupSize : groupSize;
if (groupSize === 0) {
if (idx > 0) parts.push(integer.substring(0, idx));
break;
}
}
integer = parts.reverse().join(numberFormat[COMMA$1]);
number = number.substring(0, start) + integer + number.substring(end);
}
return number;
}
/**
* Round a number to specified precision
*/
round(value, precision, negative) {
return NumberFormatterService.round(value, precision, negative);
}
/**
* Static method for rounding numbers (used externally by other components)
*/
static round(value, precision, negative) {
precision = precision || 0;
let parts = value.toString().split("e");
let rounded = Math.round(+(parts[0] + "e" + (parts[1] ? +parts[1] + precision : precision)));
if (negative) rounded = -rounded;
parts = rounded.toString().split("e");
return (+(parts[0] + "e" + (parts[1] ? +parts[1] - precision : -precision))).toFixed(Math.min(precision, 20));
}
}();
//#endregion
//#region ../src/core/services/date-formatter.service.ts
const DATE_FORMAT_REGEX = /dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|HH|H|hh|h|mm|m|fff|ff|f|tt|aa|ss|s|zzz|zz|z|EEEE|"[^"]*"|'[^']*'/g;
/**
* Pad a number with leading zeros
*/
function pad(value, length = 2) {
let str = String(value);
while (str.length < length) str = "0" + str;
return str;
}
var DateFormatterService = class {
format(date, format, culture) {
const calendar = (culture ? cultureService.getCulture(culture) : cultureService.culture()).calendars.standard;
const days = calendar.days;
const months = calendar.months;
return (format.pattern || calendar.patterns[format] || format).replace(DATE_FORMAT_REGEX, (match) => {
return this.formatMatch(match, date, calendar, days, months);
});
}
formatMatch(match, date, calendar, days, months) {
let result;
let minutes;
let sign;
if (match === "d") result = date.getDate();
else if (match === "dd") result = pad(date.getDate());
else if (match === "ddd") result = days.namesAbbr[date.getDay()];
else if (match === "dddd" || match === "EEEE") result = days.names[date.getDay()];
else if (match === "M") result = date.getMonth() + 1;
else if (match === "MM") result = pad(date.getMonth() + 1);
else if (match === "MMM") result = months.namesAbbr[date.getMonth()];
else if (match === "MMMM") result = months.names[date.getMonth()];
else if (match === "yy") result = pad(date.getFullYear() % 100);
else if (match === "yyyy") result = pad(date.getFullYear(), 4);
else if (match === "h") result = date.getHours() % 12 || 12;
else if (match === "hh") result = pad(date.getHours() % 12 || 12);
else if (match === "H") result = date.getHours();
else if (match === "HH") result = pad(date.getHours());
else if (match === "m") result = date.getMinutes();
else if (match === "mm") result = pad(date.getMinutes());
else if (match === "s") result = date.getSeconds();
else if (match === "ss") result = pad(date.getSeconds());
else if (match === "f") result = Math.floor(date.getMilliseconds() / 100);
else if (match === "ff") {
let ms = date.getMilliseconds();
if (ms > 99) ms = Math.floor(ms / 10);
result = pad(ms);
} else if (match === "fff") result = pad(date.getMilliseconds(), 3);
else if (match === "tt" || match === "aa") result = date.getHours() < 12 ? calendar.AM[0] : calendar.PM[0];
else if (match === "zzz") {
minutes = date.getTimezoneOffset();
sign = minutes < 0;
let hours = Math.abs(minutes / 60).toString().split(".")[0];
minutes = Math.abs(minutes) - parseInt(hours, 10) * 60;
result = (sign ? "+" : "-") + pad(parseInt(hours, 10));
result += ":" + pad(minutes);
} else if (match === "zz" || match === "z") {
let hours = date.getTimezoneOffset() / 60;
sign = hours < 0;
const absHours = Math.abs(hours).toString().split(".")[0];
result = (sign ? "+" : "-") + (match === "zz" ? pad(parseInt(absHours, 10)) : absHours);
}
return result !== void 0 ? result : match.slice(1, match.length - 1);
}
};
const dateFormatterService = new DateFormatterService();
//#endregion
//#region ../src/core/services/formatter.service.ts
const DATE_OBJECT$1 = "[object Date]";
const FORMAT_REGEX = /\{(\d+)(:[^\}]+)?\}/g;
const objectToString$1 = {}.toString;
var FormatterService = class {
/**
* Format a value to string, or return it as-is if no format specified.
*/
toString(value, format, culture) {
if (format) {
if (objectToString$1.call(value) === DATE_OBJECT$1) return dateFormatterService.format(value, format, culture);
else if (typeof value === "number") return numberFormatterService.format(value, format, culture);
}
return value !== void 0 ? value : "";
}
format(fmt, ...values) {
return fmt.replace(FORMAT_REGEX, (_, index, placeholderFormat) => {
const value = values[parseInt(index, 10)];
const result = this.toString(value, placeholderFormat ? placeholderFormat.substring(1) : "");
return String(result);
});
}
extractFormat(format) {
if (format.slice(0, 3) === "{0:") format = format.slice(3, format.length - 1);
return format;
}
round(value, precision, negative) {
return numberFormatterService.round(value, precision, negative);
}
};
const formatterService = new FormatterService();
//#endregion
//#region ../src/core/services/number-parser.service.ts
const DOT = ".";
const COMMA = ",";
const SPACE = " ";
const MINUS = "-";
const EXPONENT_REGEX = /[eE][\-+]?[0-9]+/;
const NON_BREAKING_SPACE_REGEX = /\u00A0/g;
const WHITESPACE_REGEX = /\s/g;
var NumberParserService = class {
/**
* Parse a string value as an integer according to culture settings
*/
parseInt(value, culture) {
const result = this.parseFloat(value, culture);
if (result) return result | 0;
return result;
}
/**
* Parse a string value as a float according to culture settings
*/
parseFloat(value, culture, format) {
if (!value && value !== 0) return null;
if (typeof value === "number") return value;
let strValue = value.toString();
let numberFormat = cultureService.getCulture(culture).numberFormat;
const percent = numberFormat.percent;
const currency = numberFormat.currency;
const percentSymbol = percent.symbol;
let symbol = currency.symbol;
let negative = strValue.indexOf(MINUS);
let parts;
let isPercent = false;
if (EXPONENT_REGEX.test(strValue)) {
const parsed = parseFloat(strValue.replace(numberFormat[DOT], DOT));
if (isNaN(parsed)) return null;
return parsed;
}
if (negative > 0) return null;
else negative = negative > -1 ? 1 : 0;
if (strValue.indexOf(symbol) > -1 || format && format.toLowerCase().indexOf("c") > -1) {
numberFormat = currency;
parts = numberFormat.pattern[0].replace("$", symbol).split("n");
if (strValue.indexOf(parts[0]) > -1 && strValue.indexOf(parts[1]) > -1) {
strValue = strValue.replace(parts[0], "").replace(parts[1], "");
negative = 1;
}
} else if (strValue.indexOf(percentSymbol) > -1) {
isPercent = true;
numberFormat = percent;
symbol = percentSymbol;
}
strValue = strValue.replace(MINUS, "").replace(symbol, "").replace(NON_BREAKING_SPACE_REGEX, SPACE).split(numberFormat[COMMA].replace(NON_BREAKING_SPACE_REGEX, SPACE)).join("").replace(WHITESPACE_REGEX, "").replace(numberFormat[DOT], DOT);
let result = parseFloat(strValue);
if (isNaN(result)) result = null;
else if (negative) result *= -1;
if (result && isPercent) result /= 100;
return result;
}
};
const numberParserService = new NumberParserService();
//#endregion
//#region ../src/core/services/date-parser.service.ts
const DATE_OBJECT = "[object Date]";
const objectToString = {}.toString;
const SHORT_TIMEZONE_REGEX = /[+|\-]\d{1,2}/;
const LONG_TIMEZONE_REGEX = /[+|\-]\d{1,2}:?\d{2}/;
const MICROSOFT_DATE_REGEX = /^\/Date\((.*?)\)\/$/;
const OFFSET_REGEX = /[+-]\d*/;
const FORMATS_SEQUENCE = [
[],
[
"G",
"g",
"F"
],
[
"D",
"d",
"y",
"m",
"T",
"t"
]
];
const STANDARD_FORMATS = [
[
"yyyy-MM-ddTHH:mm:ss.fffffffzzz",
"yyyy-MM-ddTHH:mm:ss.fffffff",
"yyyy-MM-ddTHH:mm:ss.fffzzz",
"yyyy-MM-ddTHH:mm:ss.fff",
"ddd MMM dd yyyy HH:mm:ss",
"yyyy-MM-ddTHH:mm:sszzz",
"yyyy-MM-ddTHH:mmzzz",
"yyyy-MM-ddTHH:mmzz",
"yyyy-MM-ddTHH:mm:ss",
"yyyy-MM-dd HH:mm:ss",
"yyyy/MM/dd HH:mm:ss"
],
[
"yyyy-MM-ddTHH:mm",
"yyyy-MM-dd HH:mm",
"yyyy/MM/dd HH:mm"
],
[
"yyyy/MM/dd",
"yyyy-MM-dd",
"HH:mm:ss",
"HH:mm"
]
];
const NUMBER_REGEX = {
2: /^\d{1,2}/,
3: /^\d{1,3}/,
4: /^\d{4}/,
exact3: /^\d{3}/
};
var DateParserService = class {
constructor() {
this.timezoneService = null;
}
/**
* Set the timezone service (injected later due to circular dependency)
*/
setTimezoneService(timezoneService) {
this.timezoneService = timezoneService;
}
/**
* Parse a date string according to specified formats and culture
*/
parseDate(value, formats, culture, shouldUnpadZeros) {
return this.internalParseDate(value, formats, culture, false, shouldUnpadZeros);
}
/**
* Parse a date string using exact format matching
*/
parseExactDate(value, formats, culture) {
return this.internalParseDate(value, formats, culture, true);
}
internalParseDate(value, formats, culture, strict, shouldUnpadZeros) {
if (objectToString.call(value) === DATE_OBJECT) return value;
if (!value) return null;
const strValue = String(value);
let date = null;
let tzoffset;
if (strValue.indexOf("/D") === 0) {
const dateMatch = MICROSOFT_DATE_REGEX.exec(strValue);
if (dateMatch) {
let dateStr = dateMatch[1];
tzoffset = OFFSET_REGEX.exec(dateStr.substring(1));
date = new Date(parseInt(dateStr, 10));
if (tzoffset && this.timezoneService) {
const offset = this.parseMicrosoftFormatOffset(tzoffset[0]);
date = this.timezoneService.apply(date, 0);
date = this.timezoneService.convert(date, 0, -1 * offset);
}
return date;
}
}
const resolvedCulture = cultureService.getCulture(culture);
let formatArray;
if (!formats) formatArray = this.getDefaultFormats(resolvedCulture);
else formatArray = Array.isArray(formats) ? formats : [formats];
for (let idx = 0; idx < formatArray.length; idx++) {
date = this.parseExact(strValue, formatArray[idx], resolvedCulture, strict, shouldUnpadZeros);
if (date) return date;
}
return date;
}
parseExact(value, format, culture, strict, shouldUnpadZeros) {
if (!value) return null;
const calendar = culture.calendars.standard;
let idx = 0;
let valueIdx = 0;
const lookAhead = (match) => {
let i = 0;
while (format[idx] === match) {
i++;
idx++;
}
if (i > 0) idx -= 1;
return i;
};
const getNumber = (size) => {
let part = "";
if (size === 2) for (let i = 0; i <= size; i++) part += value[valueIdx + i] || "";
if (shouldUnpadZeros && part.match(NUMBER_REGEX.exact3) && Number.isInteger(Number(part)) && Number(part) > 0) part = this.unpadZero(part);
else part = value.substr(valueIdx, size);
const rg = NUMBER_REGEX[size] || new RegExp("^\\d{1," + size + "}");
const match = part.match(rg);
if (match) {
const matchStr = match[0];
valueIdx += matchStr.length;
return parseInt(matchStr, 10);
}
return null;
};
const getIndexByName = (names, lower, subLength) => {
let matchLength = 0;
let matchIdx = 0;
for (let i = 0; i < names.length; i++) {
const name = names[i];
const nameLength = name.length;
let subValue = value.substr(valueIdx, subLength || nameLength);
if (lower) subValue = subValue.toLowerCase();
if (subValue === name && nameLength > matchLength) {
matchLength = nameLength;
matchIdx = i;
}
}
if (matchLength) {
valueIdx += matchLength;
return matchIdx + 1;
}
return null;
};
const checkLiteral = () => {
if (value.charAt(valueIdx) === format[idx]) {
valueIdx++;
return true;
}
return false;
};
let year = null;
let month = null;
let day = null;
let hours = null;
let minutes = null;
let seconds = null;
let milliseconds = null;
let literal = false;
const date = /* @__PURE__ */ new Date();
const twoDigitYearMax = calendar.twoDigitYearMax || 2029;
const defaultYear = date.getFullYear();
let pmHour = null;
let UTC;
let hoursOffset = null;
let minutesOffset = null;
if (!format) format = "d";
const pattern = calendar.patterns[format];
if (pattern) format = pattern;
const formatChars = format.split("");
const length = formatChars.length;
if (!calendar._lowerDays) calendar._lowerDays = this.lowerLocalInfo(calendar.days);
if (!calendar._lowerMonths) calendar._lowerMonths = this.lowerLocalInfo(calendar.months);
for (; idx < length; idx++) {
const ch = formatChars[idx];
if (literal) if (ch === "'") literal = false;
else checkLiteral();
else if (ch === "d") {
const count = lookAhead("d");
if (day !== null && count > 2) continue;
day = count < 3 ? getNumber(2) : getIndexByName(calendar._lowerDays[count === 3 ? "namesAbbr" : "names"], true);
if (day === null || this.outOfRange(day, 1, 31)) return null;
} else if (ch === "M") {
const count = lookAhead("M");
month = count < 3 ? getNumber(2) : getIndexByName(calendar._lowerMonths[count === 3 ? "namesAbbr" : "names"], true);
if (month === null || this.outOfRange(month, 1, 12)) return null;
month -= 1;
} else if (ch === "y") {
const count = lookAhead("y");
year = getNumber(count);
if (year === null) return null;
if (count === 2) {
let maxYear = twoDigitYearMax;
if (typeof maxYear === "string") maxYear = defaultYear + parseInt(maxYear, 10);
year = defaultYear - defaultYear % 100 + year;
if (year > maxYear) year -= 100;
}
} else if (ch === "h") {
lookAhead("h");
hours = getNumber(2);
if (hours === 12) hours = 0;
if (hours === null || this.outOfRange(hours, 0, 11)) return null;
} else if (ch === "H") {
lookAhead("H");
hours = getNumber(2);
if (hours === null || this.outOfRange(hours, 0, 23)) return null;
} else if (ch === "m") {
lookAhead("m");
minutes = getNumber(2);
if (minutes === null || this.outOfRange(minutes, 0, 59)) return null;
} else if (ch === "s") {
lookAhead("s");
seconds = getNumber(2);
if (seconds === null || this.outOfRange(seconds, 0, 59)) return null;
} else if (ch === "f") {
const count = lookAhead("f");
const match = value.substr(valueIdx, count).match(NUMBER_REGEX[3]);
milliseconds = getNumber(count);
if (milliseconds !== null && match) {
let ms = parseFloat("0." + match[0]);
ms = parseFloat(numberFormatterService.round(ms, 3));
milliseconds = ms * 1e3;
}
if (milliseconds === null || this.outOfRange(milliseconds, 0, 999)) return null;
} else if (ch === "t") {
const count = lookAhead("t");
let amDesignators = calendar.AM;
let pmDesignators = calendar.PM;
if (count === 1) {
amDesignators = this.mapDesignators(amDesignators);
pmDesignators = this.mapDesignators(pmDesignators);
}
pmHour = getIndexByName(pmDesignators, false, this.longestStringLength(pmDesignators));
if (!pmHour && !getIndexByName(amDesignators, false, this.longestStringLength(amDesignators))) return null;
} else if (ch === "z") {
UTC = true;
const count = lookAhead("z");
if (value.substr(valueIdx, 1) === "Z") {
checkLiteral();
continue;
}
const matches = value.substr(valueIdx, 6).match(count > 2 ? LONG_TIMEZONE_REGEX : SHORT_TIMEZONE_REGEX);
if (!matches) return null;
const matchParts = matches[0].split(":");
let hoursOffsetStr = matchParts[0];
let minutesOffsetStr = matchParts[1];
if (!minutesOffsetStr && hoursOffsetStr.length > 3) {
valueIdx = hoursOffsetStr.length - 2;
minutesOffsetStr = hoursOffsetStr.substring(valueIdx);
hoursOffsetStr = hoursOffsetStr.substring(0, valueIdx);
}
hoursOffset = parseInt(hoursOffsetStr, 10);
if (this.outOfRange(hoursOffset, -12, 13)) return null;
if (count > 2) {
minutesOffsetStr = matchParts[0][0] + minutesOffsetStr;
minutesOffset = parseInt(minutesOffsetStr, 10);
if (isNaN(minutesOffset) || this.outOfRange(minutesOffset, -59, 59)) return null;
}
} else if (ch === "'") {
literal = true;
checkLiteral();
} else if (!checkLiteral()) return null;
}
if (strict && !/^\s*$/.test(value.substr(valueIdx))) return null;
if (year === null && month === null && day === null && (hours !== null || minutes !== null || seconds !== null)) {
year = defaultYear;
month = date.getMonth();
day = date.getDate();
} else {
if (year === null) year = defaultYear;
if (day === null) day = 1;
}
if (pmHour && hours !== null && hours < 12) hours += 12;
let result;
if (UTC) {
if (hoursOffset && hours !== null) hours += -hoursOffset;
if (minutesOffset && minutes !== null) minutes += -minutesOffset;
result = new Date(Date.UTC(year, month ?? 0, day, hours ?? 0, minutes ?? 0, seconds ?? 0, milliseconds ?? 0));
} else {
result = new Date(year, month ?? 0, day, hours ?? 0, minutes ?? 0, seconds ?? 0, milliseconds ?? 0);
this.adjustDST(result, hours);
}
if (year < 100) result.setFullYear(year);
if (result.getDate() !== day && UTC === void 0) return null;
return result;
}
parseMicrosoftFormatOffset(offset) {
const sign = offset.substr(0, 1) === "-" ? -1 : 1;
offset = offset.substring(1);
return sign * (parseInt(offset.substr(0, 2), 10) * 60 + parseInt(offset.substring(2), 10));
}
getDefaultFormats(culture) {
const length = Math.max(FORMATS_SEQUENCE.length, STANDARD_FORMATS.length);
const patterns = (culture.calendar || culture.calendars.standard).patterns;
const formats = [];
for (let idx = 0; idx < length; idx++) {
const cultureFormats = FORMATS_SEQUENCE[idx] || [];
for (let formatIdx = 0; formatIdx < cultureFormats.length; formatIdx++) formats.push(patterns[cultureFormats[formatIdx]]);
formats.push(...STANDARD_FORMATS[idx] || []);
}
return formats;
}
outOfRange(value, start, end) {
return !(value >= start && value <= end);
}
adjustDST(date, hours) {
if (!hours && date.getHours() === 23) date.setHours(date.getHours() + 2);
}
lowerLocalInfo(data) {
return {
names: data.names.map((s) => s.toLowerCase()),
namesAbbr: data.namesAbbr.map((s) => s.toLowerCase())
};
}
unpadZero(value) {
return value.replace(/^0*/, "");
}
mapDesignators(designators) {
return designators.map((d) => d.charAt(0));
}
longestStringLength(strings) {
return strings.reduce((max, s) => Math.max(max, s.length), 0);
}
};
const dateParserService = new DateParserService();
//#endregion
//#region ../src/core/services/kendo-culture-to-intl.service.ts
/**
* Service that converts Kendo cultures to Intl-compatible format
* Used for integration with @progress/kendo-intl
*/
var KendoCultureToIntlService = class {
/**
* Convert a Kendo culture to an Intl-compatible adapter
*/
convert(culture) {
const kendoCulture = cultureService.getCulture(culture) || cultureService.culture();
const currencies = {};
currencies[kendoCulture.numberFormat.currency.abbr] = kendoCulture.numberFormat.currency;
return {
localeInfo: () => this.buildLocaleInfo(kendoCulture, currencies),
parseDate: (value, fmt) => dateParserService.parseExactDate(value, fmt, kendoCulture),
toString: (value, fmt) => {
const result = formatterService.toString(value, fmt, kendoCulture);
return result == null ? "" : String(result);
},
format: (fmt, ...values) => formatterService.format(fmt, ...values)
};
}
buildLocaleInfo(kendoCulture, currencies) {
return {
numbers: {
localeCurrency: kendoCulture.numberFormat.currency.abbr,
currencies,
symbols: {
group: kendoCulture.numberFormat[","],
decimal: kendoCulture.numberFormat["."],
percentSign: kendoCulture.numberFormat.percent.symbol
}
},
calendar: {
patterns: kendoCulture.calendars.standard.patterns,
months: { format: {
wide: kendoCulture.calendars.standard.months.names,
abbreviated: kendoCulture.calendars.standard.months.namesAbbr
} },
days: { format: {
wide: kendoCulture.calendars.standard.days.names,
abbreviated: kendoCulture.calendars.standard.days.namesAbbr
} }
}
};
}
buildLocaleInfoAll(kendoCulture, currencies) {
const localeInfoAll = {};
const [language, territory] = kendoCulture.name.split("-");
localeInfoAll.name = language;
localeInfoAll.identity = { language };
if (territory) localeInfoAll.territory = territory;
if (kendoCulture.numberFormat) {
localeInfoAll.numbers = {
symbols: {
decimal: kendoCulture.numberFormat["."],
group: kendoCulture.numberFormat[","],
percentSign: kendoCulture.numberFormat.percent?.symbol || "%"
},
decimal: {
patterns: kendoCulture.numberFormat.pattern,
groupSize: kendoCulture.numberFormat.groupSize
},
currency: {
patterns: kendoCulture.numberFormat.currency?.pattern,
groupSize: kendoCulture.numberFormat.currency?.groupSize
},
percent: {
patterns: kendoCulture.numberFormat.percent?.pattern,
groupSize: kendoCulture.numberFormat.percent?.groupSize,
decimals: kendoCulture.numberFormat.percent?.decimals
}
};
if (kendoCulture.numberFormat.currency) {
localeInfoAll.numbers.currencies = { [kendoCulture.numberFormat.currency.abbr]: kendoCulture.numberFormat.currency };
localeInfoAll.numbers.localeCurrency = kendoCulture.numberFormat.currency.abbr;
}
}
if (kendoCulture.calendars && kendoCulture.calendars.standard) {
const standardCalendar = kendoCulture.calendars.standard;
localeInfoAll.calendar = {
patterns: {
d: standardCalendar.patterns.d,
D: standardCalendar.patterns.D,
F: standardCalendar.patterns.F,
g: standardCalendar.patterns.g,
G: standardCalendar.patterns.G,
m: standardCalendar.patterns.m,
M: standardCalendar.patterns.M,
s: standardCalendar.patterns.s,
t: standardCalendar.patterns.t,
T: standardCalendar.patterns.T,
u: standardCalendar.patterns.u,
y: standardCalendar.patterns.y,
Y: standardCalendar.patterns.Y
},
days: {
format: {
wide: standardCalendar.days.names,
abbreviated: standardCalendar.days.namesAbbr,
short: standardCalendar.days.namesShort
},
"stand-alone": {
wide: standardCalendar.days.names,
abbreviated: standardCalendar.days.namesAbbr,
short: standardCalendar.days.namesShort
}
},
months: {
format: {
wide: standardCalendar.months.names,
abbreviated: standardCalendar.months.namesAbbr,
narrow: standardCalendar.months.namesAbbr.map((name) => name.charAt(0))
},
"stand-alone": {
wide: standardCalendar.months.names,
abbreviated: standardCalendar.months.namesAbbr,
narrow: standardCalendar.months.namesAbbr.map((name) => name.charAt(0))
}
},
dayPeriods: {
format: {
abbreviated: {
am: standardCalendar.AM[0],
pm: standardCalendar.PM[0]
},
narrow: {
am: standardCalendar.AM[1],
pm: standardCalendar.PM[1]
},
wide: {
am: standardCalendar.AM[0],
pm: standardCalendar.PM[0]
}
},
"stand-alone": {
abbreviated: {
am: standardCalendar.AM[0],
pm: standardCalendar.PM[0]
},
narrow: {
am: standardCalendar.AM[1],
pm: standardCalendar.PM[1]
},
wide: {
am: standardCalendar.AM[0],
pm: standardCalendar.PM[0]
}
}
}
};
if ("firstDay" in standardCalendar) localeInfoAll.firstDay = standardCalendar.firstDay;
}
return localeInfoAll;
}
};
const intlService = new KendoCultureToIntlService();
//#endregion
//#region ../src/core/services/template.service.ts
const argumentNameRegExp = /^\w+/;
const encodeRegExp = /\$\{([^}]*)\}/g;
const escapedCurlyRegExp = /\\\}/g;
const curlyRegExp = /__CURLY__/g;
const escapedSharpRegExp = /\\#/g;
const sharpRegExp = /__SHARP__/g;
/**
* Compile a template part (either string literal or code)
*/
function compilePart(part, stringPart) {
if (stringPart) return "'" + part.split("'").join("\\'").split("\\\"").join("\\\\\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t") + "'";
else {
const first = part.charAt(0);
const rest = part.substring(1);
if (first === "=") return "+(" + rest + ")+";
else if (first === ":") return "+$kendoHtmlEncode(" + rest + ")+";
else return ";" + part + ";$kendoOutput+=";
}
}
/**
* Template service for compiling and rendering Kendo UI templates
*
* Supports the legacy Kendo template syntax:
* - #= expression # - Output expression result
* - #: expression # - Output HTML-encoded expression result
* - # code # - Execute JavaScript code
*/
var TemplateService = class {
constructor() {
this.paramName = "data";
this.useWithBlock = true;
this.debugTemplates = false;
}
/**
* Enable or disable template debugging
*/
setDebugMode(enabled) {
this.debugTemplates = enabled;
}
/**
* Render a template with an array of data items
*/
render(template, data) {
let html = "";
for (let idx = 0; idx < data.length; idx++) html += template(data[idx]);
return html;
}
/**
* Compile a template string into a function
*/
compile(template, options) {
if (typeof template === "function") return template;
const settings = {
paramName: options?.paramName !== void 0 ? options.paramName : this.paramName,
useWithBlock: options?.useWithBlock !== void 0 ? options.useWithBlock : this.useWithBlock
};
const paramName = settings.paramName;
const argumentName = paramName.match(argumentNameRegExp)[0];
const useWithBlock = settings.useWithBlock;
let functionBody = "var $kendoOutput, $kendoHtmlEncode = kendo.htmlEncode;";
functionBody += useWithBlock ? "with(" + paramName + "){" : "";
functionBody += "$kendoOutput=";
const parts = template.replace(escapedCurlyRegExp, "__CURLY__").replace(encodeRegExp, "#=$kendoHtmlEncode($1)#").replace(curlyRegExp, "}").replace(escapedSharpRegExp, "__SHARP__").split("#");
for (let idx = 0; idx < parts.length; idx++) functionBody += compilePart(parts[idx], idx % 2 === 0);
functionBody += useWithBlock ? ";}" : ";";
functionBody += "return $kendoOutput;";
functionBody = functionBody.replace(sharpRegExp, "#");
try {
const fn = new Function(argumentName, functionBody);
fn._slotCount = Math.floor(parts.length / 2);
return fn;
} catch (e) {
if (this.debugTemplates) {
console.warn(`Invalid template:'${template}' Generated code:'${functionBody}'`);
return (() => "");
} else throw new Error(formatterService.format("Invalid template:'{0}' Generated code:'{1}'", template, functionBody));
}
}
};
const templateService = new TemplateService();
//#endregion
//#region ../src/core/services/html.service.ts
const ampRegExp = /&/g;
const ltRegExp = /</g;
const quoteRegExp = /"/g;
const aposRegExp = /'/g;
const gtRegExp = />/g;
const ALLOWED_PROTOCOLS = ["http:", "https:"];
/**
* Service for HTML encoding, decoding, and sanitization
*/
var HtmlService = class {
/**
* Decode HTML entities to their character equivalents
*/
decode(value) {
const entities = {
"&": "&",
"<": "<",
">": ">",
""": "\"",
"'": "'"
};
return value.replace(/&(?:amp|lt|gt|quot|#39);/g, function(match) {
return entities[match];
});
}
/**
* Encode special characters to HTML entities
*/
encode(value, shouldDecode) {
if (shouldDecode === true) value = this.decode(value);
return ("" + value).replace(ampRegExp, "&").replace(ltRegExp, "<").replace(gtRegExp, ">").replace(quoteRegExp, """).replace(aposRegExp, "'");
}
/**
* Sanitize a URL to prevent XSS attacks
* Only allows http: and https: protocols
*/
sanitizeLink(value) {
let link = "";
try {
const url = new URL(value, window.location.origin);
if (ALLOWED_PROTOCOLS.includes(url.protocol)) link = value;
else throw new Error("Invalid protocol");
} catch {
link = "#INVALIDLINK";
}
return this.encode(link);
}
/**
* Convert text URLs to clickable HTML links
*/
convertTextUrlToLink(text, skipSanitization) {
return (skipSanitization ? text : this.encode(text)).replace(/((https?:\/\/[^\s"'<>]+)|(www\.[^\s"'<>]+))/gi, (match, _p1, _p2, _p3, offset, fullString) => {
const lastTagClose = fullString.lastIndexOf(">", offset - 1);
const beforeMatch = fullString.substring(lastTagClose + 1, offset);
if (/\w+\s*=\s*["']$/.test(beforeMatch)) return match;
let url = match.trim();
const displayText = match.trim();
if (/^www\./i.test(url)) url = "https://" + url;
try {
url = new URL(url).href;
return `<a href="${url}" target="_blank" rel="noopener noreferrer">${displayText}</a>`;
} catch (e) {
return match;
}
});
}
/**
* Unescape URL-encoded strings
*/
unescape(value) {
let template;
try {
template = window.decodeURIComponent(value);
} catch (error) {
template = value.replace(/%u([\dA-F]{4})|%([\dA-F]{2})/gi, function(_, m1, m2) {
return String.fromCharCode(parseInt("0x" + (m1 || m2), 16));
});
}
return template;
}
};
const htmlService = new HtmlService();
//#endregion
//#region ../src/core/services/date-utils.service.ts
/**
* Service providing date utility functions
* Extracted from kendo.date namespace
*/
var DateUtilsService = class {
constructor() {
this.MS_PER_MINUTE = 6e4;
this.MS_PER_HOUR = 60 * 6e4;
this.MS_PER_DAY = 864e5;
}
/**
* Adjust date for DST changes
*/
adjustDST(date, hours) {
if (hours === 0 && date.getHours() === 23) {
date.setHours(date.getHours() + 2);
return true;
}
return false;
}
/**
* Set the day of week on a date (mutates the date)
*/
setDayOfWeek(date, day, dir = 1) {
const hours = date.getHours();
day = (day - date.getDay() + 7 * dir) % 7;
date.setDate(date.getDate() + day);
this.adjustDST(date, hours);
}
/**
* Get a new date set to the specified day of week
*/
dayOfWeek(date, day, dir) {
date = new Date(date);
this.setDayOfWeek(date, day, dir);
return date;
}
/**
* Get the first day of the month
*/
firstDayOfMonth(date) {
return new Date(date.getFullYear(), date.getMonth(), 1);
}
/**
* Get the last day of the month
*/
lastDayOfMonth(date) {
const last = new Date(date.getFullYear(), date.getMonth() + 1, 0);
const first = this.firstDayOfMonth(date);
const timeOffset = Math.abs(last.getTimezoneOffset() - first.getTimezoneOffset());
if (timeOffset) last.setHours(first.getHours() + timeOffset / 60);
return last;
}
/**
* Get the first day of the year
*/
firstDayOfYear(date) {
return new Date(date.getFullYear(), 0, 1);
}
/**
* Get the last day of the year
*/
lastDayOfYear(date) {
return new Date(date.getFullYear(), 11, 31);
}
/**
* Move date to week start for week calculation
*/
moveDateToWeekStart(date, weekStartDay) {
if (weekStartDay !== 1) return this.addDays(this.dayOfWeek(date, weekStartDay, -1), 4);
return this.addDays(date, 4 - (date.getDay() || 7));
}
/**
* Calculate week number in year
*/
calcWeekInYear(date, weekStartDay) {
const firstWeekInYear = new Date(date.getFullYear(), 0, 1, -6);
const diffInMS = this.moveDateToWeekStart(date, weekStartDay).getTime() - firstWeekInYear.getTime();
const days = Math.floor(diffInMS / this.MS_PER_DAY);
return 1 + Math.floor(days / 7);
}
/**
* Get the week number in the year
*/
weekInYear(date, weekStartDay) {
if (weekStartDay === void 0) weekStartDay = cultureService.culture().calendar.firstDay;
const prevWeekDate = this.addDays(date, -7);
const nextWeekDate = this.addDays(date, 7);
const weekNumber = this.calcWeekInYear(date, weekStartDay);
if (weekNumber === 0) return this.calcWeekInYear(prevWeekDate, weekStartDay) + 1;
if (weekNumber === 53 && this.calcWeekInYear(nextWeekDate, weekStartDay) > 1) return 1;
return weekNumber;
}
/**
* Get a date with time set to midnight
*/
getDate(date) {
date = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0);
this.adjustDST(date, 0);
return date;
}
/**
* Convert date to UTC time
*/
toUtcTime(date) {
return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
}
/**
* Get milliseconds from midnight
*/
getMilliseconds(date) {
return this.toInvariantTime(date).getTime() - this.getDate(this.toInvariantTime(date)).getTime();
}
/**
* Check if a time value is within a range
*/
isInTimeRange(value, min, max) {
let msMin = this.getMilliseconds(min);
let msMax = this.getMilliseconds(max);
if (!value || msMin === msMax) return true;
if (min >= max) msMax += this.MS_PER_DAY;
let msValue = this.getMilliseconds(value);
if (msMin > msValue) msValue += this.MS_PER_DAY;
if (msMax < msMin) msMax += this.MS_PER_DAY;
return msValue >= msMin && msValue <= msMax;
}
/**
* Check if a date value is within a range
*/
isInDateRange(value, min, max) {
let msMin = min.getTime();
let msMax = max.getTime();
if (msMin >= msMax) msMax += this.MS_PER_DAY;
const msValue = value.getTime();
return msValue >= msMin && msValue <= msMax;
}
/**
* Add days to a date
*/
addDays(date, offset) {
const hours = date.getHours();
date = new Date(date);
this.setTime(date, offset * this.MS_PER_DAY);
this.adjustDST(date, hours);
return date;
}
/**
* Set time on a date (mutates the date)
*/
setTime(date, milliseconds, ignoreDST) {
const offset = date.getTimezoneOffset();
date.setTime(date.getTime() + milliseconds);
if (!ignoreDST) {
const difference = date.getTimezoneOffset() - offset;
date.setTime(date.getTime() + difference * this.MS_PER_MINUTE);
}
}
/**
* Set hours from another date/time
*/
setHours(date, time) {
date = new Date(date.getFullYear(), date.getMonth(), date.getDate(), time.getHours(), time.getMinutes(), time.getSeconds(), time.getMilliseconds());
this.adjustDST(date, time.getHours());
return date;
}
/**
* Get today's date (midnight)
*/
today() {
return this.getDate(/* @__PURE__ */ new Date());
}
/**
* Check if a date is today
*/
isToday(date) {
return this.getDate(date).getTime() === this.today().getTime();
}
/**
* Convert date to invariant time (fixed date, preserves time)
*/
toInvariantTime(date) {
const staticDate = new Date(1980, 1, 1, 0, 0, 0);
if (date) staticDate.setHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
return staticDate;
}
/**
* Add years to a date
*/
addYear(date, offset) {
const currentDate = new Date(date);
return new Date(currentDate.setFullYear(currentDate.getFullYear() + offset));
}
/**
* Get the next day
*/
nextDay(date) {
return this.addDays(date, 1);
}
/**
* Get the previous day
*/
previousDay(date) {
return this.addDays(date, -1);
}
/**
* Get the next year
*/
nextYear(date) {
return this.addYear(date, 1);
}
/**
* Get the previous year
*/
previousYear(date) {
return this.addYear(date, -1);
}
/**
* Add literal part to date format parts array
*/
addLiteral(parts, value) {
const lastPart = parts[parts.length - 1];
if (lastPart && lastPart.type === "LITERAL") lastPart.pattern += value;
else parts.push({
type: "literal",
pattern: value
});
}
/**
* Check if hour pattern is 12-hour format
*/
isHour12(pattern) {
return pattern === "h" || pattern === "K";
}
/**
* Get date name type based on format length
*/
dateNameType(formatLength) {
if (formatLength <= 3) return "abbreviated";
else if (formatLength === 4) return "wide";
else if (formatLength === 5) return "narrow";
}
/**
* Check if text starts with search string
*/
startsWith(text, searchString, position = 0) {
return text.indexOf(searchString, position) === position;
}
/**
* Get date pattern from format
*/
datePattern(format, info) {
const calendar = info.calendar;
let result;
if (typeof format === "string") if (calendar.patterns[format]) result = calendar.patterns[format];
else result = format;
if (!result) result = calendar.patterns.d;
return result;
}
/**
* Split a date format string into parts
*/
splitDateFormat(format) {
const info = cultureService.culture();
const pattern = this.datePattern(format, info).replaceAll("dddd", "EEEE").replaceAll("ddd", "EEE").replace("tt", "aa");
const parts = [];
const dateFormatRegExp = /d{1,2}|E{1,6}|e{1,6}|c{3,6}|c{1}|M{1,5}|L{1,5}|y{1,4}|H{1,2}|h{1,2}|k{1,2}|K{1,2}|m{1,2}|a{1,5}|s{1,2}|S{1,3}|t{1,2}|z{1,4}|Z{1,5}|x{1,5}|X{1,5}|G{1,5}|q{1,5}|Q{1,5}|"[^"]*"|'[^']*'/g;
let lastIndex = dateFormatRegExp.lastIndex = 0;
let match = dateFormatRegExp.exec(pattern);
while (match) {
const value = match[0];
if (lastIndex < match.index) this.addLiteral(parts, pattern.substring(lastIndex, match.index));
if (this.startsWith(value, "\"") || this.startsWith(value, "'")) this.addLiteral(parts, value);
else {
const specifier = value[0];
const type = DATE_FIELD_MAP[specifier];
const part = {
type,
pattern: value
};
if (type === "hour") part.hour12 = this.isHour12(value);
const names = NAME_TYPES[type];
if (names) {
const minLength = typeof names.minLength === "number" ? names.minLength : names.minLength[specifier];
const patternLength = value.length;
if (patternLength >= minLength && value !== "aa") part.names = {
type: names.type,
nameType: this.dateNameType(patternLength) || "abbreviated",
standAlone: names.standAlone === specifier
};
}
parts.push(part);
}
lastIndex = dateFormatRegExp.lastIndex;
match = dateFormatRegExp.exec(pattern);
}
if (lastIndex < pattern.length) this.addLiteral(parts, pattern.substring(lastIndex));
return parts;
}
/**
* Get date format names (month names, day names, etc.)
*/
dateFormatNames(options) {
let { type, nameType } = options;
const info = cultureService.culture();
if (nameType === "wide") nameType = "names";
if (nameType === "abbreviated") nameType = "namesAbbr";
if (nameType === "narrow") nameType = "namesShort";
let result = info.calendar[type]?.[nameType];
if (!result) result = info.calendar[type]?.["name"];
return result || [];
}
/**
* Get date field name
*/
dateFieldName(options) {
return (cultureService.culture().calendar.dateFields?.[options.type] || {})[options.nameType];
}
/**
* Generates a relative date string (Today, Yesterday, Last Wednesday, etc.)
* @param date - The date to compare against
* @param currentDate - The current date (defaults to new Date())
* @returns Relative date string
*/
getRelativeDateString(date, currentDate = /* @__PURE__ */ new Date()) {
if (!date) return "";
const today = new Date(currentDate);
today.setHours(0, 0, 0, 0);
const dateObj = new Date(date);
dateObj.setHours(0, 0, 0, 0);
const diffTime = today.getTime() - dateObj.getTime();
const diffDays = Math.floor(diffTime / this.MS_PER_DAY);
if (diffDays === 0) return "Today";
else if (diffDays === 1) return "Yesterday";
else if (diffDays <= 6) return `Last ${formatterService.toString(dateObj, "dddd")}`;
else return String(formatterService.toString(dateObj, "dddd, MMMM dd, yyyy"));
}
};
const dateUtilsService = new DateUtilsService();
//#endregion
//#region ../src/core/services/effects.service.ts
const STRING$3 = "string";
const BOOLEAN = "boolean";
/**
* Effects Service - provides animation effects utilities
*/
var EffectsService = class {
constructor() {
this._directions = this.createDirections();
this._effects = this.createEffects();
}
/**
* Create the directions map
*/
createDirections() {
return {
left: {
reverse: "right",
property: "left",
transition: "translatex",
vertical: false,
modifier: -1
},
right: {
reverse: "left",
property: "left",
transition: "translatex",
vertical: false,
modifier: 1
},
down: {
reverse: "up",
property: "top",
transition: "translatey",
vertical: true,
modifier: 1
},
up: {
reverse: "down",
property: "top",
transition: "translatey",
vertical: true,
modifier: -1
},
top: { reverse: "bottom" },
bottom: { reverse: "top" },
"in": {
reverse: "out",
modifier: -1
},
out: {
reverse: "in",
modifier: 1
},
vertical: { reverse: "vertical" },
horizontal: { reverse: "horizontal" }
};
}
/**
* Create the effects object
*/
createEffects() {
const effects = {
enabled: true,
Element: function(element) {
this.element = $(element);
},
promise: function(element, options) {
if (!element.is(":visible")) element.css({ display: element.data("olddisplay") || "block" }).css("display");
if (options.hide) element.data("olddisplay", element.data("olddisplay") || element.css("display")).hide();
if (options.init) options.init();
if (options.completeCallback) options.completeCallback(element);
element.dequeue();
},
promiseShim: null,
disable: function() {
this.enabled = false;
this.promise = this.promiseShim;
},
enable: function() {
this.enabled = true;
this.promise = this.animatedPromise;
}
};
effects.promiseShim = effects.promise;
return effects;
}
/**
* Get the directions map for animations
*/
get directions() {
return this._directions;
}
/**
* Get the effects object
*/
get effects() {
return this._effects;
}
/**
* Prepare animation options with defaults
*/
prepareAnimationOptions(options, duration, reverse, complete) {
if (typeof options === STRING$3) {
if (utilsService.isFunction(duration)) {
complete = duration;
duration = 400;
reverse = false;
}
if (utilsService.isFunction(reverse)) {
complete = reverse;
reverse = false;
}
if (typeof duration === BOOLEAN) {
reverse = duration;
duration = 400;
}
options = {
effects: options,
duration,
reverse,
complete
};
}
return $.extend({
effects: {},
duration: 400,
reverse: false,
init: $.noop,
teardown: $.noop,
hide: false
}, options, {
completeCallback: options.complete,
complete: $.noop
});
}
/**
* Animate one or more elements
*/
animate(element, options, duration, reverse, complete) {
const effects = this._effects;
const preparedOptions = this.prepareAnimationOptions.bind(this);
let idx = 0;
const length = element.length;
let instance;
for (; idx < length; idx++) {
instance = $(element[idx]);
instance.queue(function() {
effects.promise($(this), preparedOptions(options, duration, reverse, complete));
});
}
return element;
}
/**
* Toggle CSS classes on element
*/
toggleClass(element, classes, options, add) {
if (classes) {
const classArray = classes.split(" ");
$.each(classArray, (idx, value) => {
element.toggleClass(value, add);
});
}
return element;
}
/**
* Create an effects element wrapper
*/
fx(element) {
return new this._effects.Element(element);
}
};
const effectsService = new EffectsService();
//#endregion
//#region ../src/core/services/input.service.ts
/**
* Input Service Implementation
* Provides utilities for input element manipulation.
*/
var InputService = class {
/**
* Get or set the caret (text cursor) position in an input element.
*/
caret(element, start, end) {
let rangeElement;
const isPosition = start !== void 0;
if (end === void 0) end = start;
if (element[0]) element = element[0];
const inputElement = element;
if (isPosition && inputElement.disabled) return [];
try {
if (inputElement.selectionStart !== void 0) if (isPosition) {
inputElement.focus();
const mobile = supportService.mobileOS;
if (mobile && (mobile.wp || mobile.android)) setTimeout(() => {
inputElement.setSelectionRange(start, end);
}, 0);
else inputElement.setSelectionRange(start, end);
return [start, end];
} else return [inputElement.selectionStart, inputElement.selectionEnd];
else if (document.selection) {
if ($(inputElement).is(":visible")) inputElement.focus();
rangeElement = inputElement.createTextRange();
if (isPosition) {
rangeElement.collapse(true);
rangeElement.moveStart("character", start);
rangeElement.moveEnd("character", end - start);
rangeElement.select();
return [start, end];
} else {
const rangeDuplicated = rangeElement.duplicate();
let selectionStart;
let selectionEnd;
rangeElement.moveToBookmark(document.selection.createRange().getBookmark());
rangeDuplicated.setEndPoint("EndToStart", rangeElement);
selectionStart = rangeDuplicated.text.length;
selectionEnd = selectionStart + rangeElement.text.length;
return [selectionStart, selectionEnd];
}
}
} catch (e) {
return [];
}
return [];
}
/**
* Get anti-forgery (CSRF) tokens from the page.
*/
antiForgeryTokens() {
const tokens = {};
const csrfToken = $("meta[name=csrf-token],meta[name=_csrf]").attr("content");
const csrfParam = $("meta[name=csrf-param],meta[name=_csrf_header]").attr("content");
$("input[name^='__RequestVerificationToken']").each(function() {
tokens[this.name] = this.value;
});
if (csrfParam !== void 0 && csrfToken !== void 0) tokens[csrfParam] = csrfToken;
return tokens;
}
};
const inputService = new InputService();
//#endregion
//#region ../src/core/services/file-utils.service.ts
/**
* File Utils Service - provides file-related utilities
*/
var FileUtilsService = class {
constructor() {
this._fileGroupMap = this.createFileGroupMap();
this.fileSaver = document.createElement("a");
this.downloadAttribute = "download" in this.fileSaver && !supportService.browser.edge;
}
/**
* Create the default file group mapping
*/
createFileGroupMap() {
return {
audio: [
".aif",
".iff",
".m3u",
".m4a",
".mid",
".mp3",
".mpa",
".wav",
".wma",
".ogg",
".wav",
".wma",
".wpl"
],
video: [
".3g2",
".3gp",
".avi",
".asf",
".flv",
".m4u",
".rm",
".h264",
".m4v",
".mkv",
".mov",
".mp4",
".mpg",
".rm",
".swf",
".vob",
".wmv"
],
image: [
".ai",
".dds",
".heic",
".jpe",
"jfif",
".jif",
".jp2",
".jps",
".eps",
".bmp",
".gif",
".jpeg",
".jpg",
".png",
".ps",
".psd",
".svg",
".svgz",
".tif",
".tiff"
],
txt: [
".doc",
".docx",
".log",
".pages",
".tex",
".wpd",
".wps",
".odt",
".rtf",
".text",
".txt",
".wks"
],
presentation: [
".key",
".odp",
".pps",
".ppt",
".pptx"
],
data: [
".xlr",
".xls",
".xlsx"
],
programming: [
".tmp",
".bak",
".msi",
".cab",
".cpl",
".cur",
".dll",
".dmp",
".drv",
".icns",
".ico",
".link",
".sys",
".cfg",
".ini",
".asp",
".aspx",
".cer",
".csr",
".css",
".dcr",
".htm",
".html",
".js",
".php",
".rss",
".xhtml"
],
pdf: [".pdf"],
config: [
".apk",
".app",
".bat",
".cgi",
".com",
".exe",
".gadget",
".jar",
".wsf"
],
zip: [
".7z",
".cbr",
".gz",
".sitx",
".arj",
".deb",
".pkg",
".rar",
".rpm",
".tar.gz",
".z",
".zip",
".zipx"
],
"disc-image": [
".dmg",
".iso",
".toast",
".vcd",
".bin",
".cue",
".mdf"
]
};
}
/**
* Get the file group mapping
*/
get fileGroupMap() {
return this._fileGroupMap;
}
/**
* Get file group/type based on extension
*/
getFileGroup(extension, withPrefix) {
const fileTypeMap = this._fileGroupMap;
const groups = Object.keys(fileTypeMap);
const type = "file";
if (extension === void 0 || !extension.length) return type;
let normalizedExt = extension.toLowerCase();
if (!normalizedExt.startsWith(".")) normalizedExt = "." + normalizedExt;
for (let i = 0; i < groups.length; i += 1) if (fileTypeMap[groups[i]].indexOf(normalizedExt) > -1) return withPrefix ? "file-" + groups[i] : groups[i];
return type;
}
/**
* Get human-readable file size message
*/
getFileSizeMessage(size) {
const sizes = [
"Bytes",
"KB",
"MB",
"GB",
"TB"
];
if (size === 0) return "0 Byte";
const i = parseInt(String(Math.floor(Math.log(size) / Math.log(1024))), 10);
return Math.round(size / Math.pow(1024, i)) + " " + sizes[i];
}
/**
* Post data to a proxy URL
*/
postToProxy(dataURI, fileName, proxyURL, proxyTarget) {
const form = $("<form>").attr({
action: proxyURL,
method: "POST",
target: proxyTarget
});
const data = inputService.antiForgeryTokens();
data.fileName = fileName;
const parts = dataURI.split(";base64,");
data.contentType = parts[0].replace("data:", "");
data.base64 = parts[1];
for (const name in data) if (Object.prototype.hasOwnProperty.call(data, name)) $("<input>").attr({
value: data[name],
name,
type: "hidden"
}).appendTo(form);
form.appendTo("body").submit().remove();
}
/**
* Save using msSaveBlob (IE)
*/
saveAsBlob(dataURI, fileName) {
let blob = dataURI;
if (typeof dataURI === "string") {
const parts = dataURI.split(";base64,");
const contentType = parts[0];
const base64 = atob(parts[1]);
const array = new Uint8Array(base64.length);
for (let idx = 0; idx < base64.length; idx++) array[idx] = base64.charCodeAt(idx);
blob = new Blob([array.buffer], { type: contentType });
}
navigator.msSaveBlob(blob, fileName);
}
/**
* Save using data URI and download attribute
*/
saveAsDataURI(dataURI, fileName) {
let uri = dataURI;
if (window.Blob && dataURI instanceof Blob) uri = URL.createObjectURL(dataURI);
this.fileSaver.download = fileName;
this.fileSaver.href = uri;
const e = document.createEvent("MouseEvents");
e.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
this.fileSaver.dispatchEvent(e);
setTimeout(function() {
URL.revokeObjectURL(uri);
});
}
/**
* Save data as a file download
*/
saveAs(options) {
let save = this.postToProxy.bind(this);
if (!options.forceProxy) {
if (this.downloadAttribute) save = this.saveAsDataURI.bind(this);
else if (navigator.msSaveBlob) save = this.saveAsBlob.bind(this);
}
save(options.dataURI, options.fileName, options.proxyURL, options.proxyTarget);
}
};
const fileUtilsService = new FileUtilsService();
//#endregion
//#region ../src/core/services/widget-registry.service.ts
/**
* Widget Registry Service
*
* Manages widget registration across different namespaces (ui, mobile.ui, dataviz.ui).
*
*/
const STRING$2 = "string";
const FUNCTION$1 = "function";
/**
* Widget Registry Service implementation
*/
var WidgetRegistryService = class {
constructor() {
this.widgets = [];
this.namespaces = /* @__PURE__ */ new Map();
}
isWidgetConstructor(value) {
if (typeof value !== FUNCTION$1 || value === null) return false;
const widget = value;
return "fn" in widget && "extend" in widget;
}
/**
* Create a new namespace with roles:{} and register it
* This is the primary way to create namespaces - the service owns them.
* @param name - Namespace name (e.g., "ui", "mobile.ui", "dataviz.ui")
* @param properties - Additional properties to add to the namespace
* @returns The created namespace object
*/
createNamespace(name, properties) {
const namespace = {
roles: {},
...properties
};
this.namespaces.set(name, namespace);
return namespace;
}
/**
* Get a namespace register
* @param name - Namespace name
* @returns The namespace object or undefined
*/
getNamespace(name) {
return this.namespaces.get(name);
}
/**
* Register a widget using options
*/
register(widget, options = {}) {
const namespace = options.namespace || "ui";
const register = this.namespaces.get(namespace);
if (!register) throw new Error(`Unknown widget namespace: ${namespace}`);
this.registerToNamespace(widget, register, options.prefix);
}
/**
* Register a widget to a specific namespace register
* This is the core implementation matching the original kendo.ui.plugin
*/
registerToNamespace(widget, register, prefix) {
const name = widget.fn.options.name || widget.options?.name;
if (!name) throw new Error("Widget must have a name in options");
prefix = prefix || "";
const componentName = name.toLowerCase();
register[name] = widget;
register.roles[componentName] = widget;
const getter = "getKendo" + prefix + name;
const pluginName = "kendo" + prefix + name;
this.createJQueryPlugin(pluginName, widget, getter);
const widgetEntry = {
name: pluginName,
widget,
prefix
};
this.widgets.push(widgetEntry);
}
/**
* Get a widget by name
*/
getWidget(name, namespace) {
if (namespace) {
const widget = this.namespaces.get(namespace)?.[name];
return this.isWidgetConstructor(widget) ? widget : void 0;
}
for (const register of this.namespaces.values()) {
const widget = register[name];
if (this.isWidgetConstructor(widget)) return widget;
}
}
/**
* Get a widget by role name
*/
getWidgetByRole(role, namespace) {
const lowerRole = role.toLowerCase();
if (namespace) return this.namespaces.get(namespace)?.roles[lowerRole];
for (const register of this.namespaces.values()) if (register.roles[lowerRole]) return register.roles[lowerRole];
}
/**
* Get all registered widgets
*/
getAllWidgets() {
return this.widgets.slice();
}
/**
* Get widget instance from an element
*/
getWidgetInstance(element, namespace) {
const el = $(element);
let result;
const searchNamespaces = namespace ? [namespace] : Array.from(this.namespaces.values());
for (const ns of searchNamespaces) for (const role in ns.roles) {
const widget = ns.roles[role];
const dataKey = "kendo" + (widget.fn?.options?.prefix || "") + (widget.fn?.options?.name || "");
result = el.data(dataKey);
if (result) return result;
}
}
/**
* Create jQuery plugin for a widget
*/
createJQueryPlugin(name, widget, getter) {
const slice = Array.prototype.slice;
$.fn[name] = function(options) {
let value = this;
let args;
if (typeof options === STRING$2) {
args = slice.call(arguments, 1);
this.each(function() {
const widgetInstance = $.data(this, name);
let method;
let result;
if (!widgetInstance) throw new Error(formatterService.format("Cannot call method '{0}' of {1} before it is initialized", options, name));
method = widgetInstance[options];
if (typeof method !== FUNCTION$1) throw new Error(formatterService.format("Cannot find method '{0}' of {1}", options, name));
result = method.apply(widgetInstance, args);
if (result !== void 0) {
value = result;
return false;
}
});
} else this.each(function() {
return new widget(this, options);
});
return value;
};
$.fn[name].widget = widget;
$.fn[getter] = function() {
return this.data(name);
};
}
/**
* Merge roles from multiple namespaces into a single object
*/
rolesFromNamespaces(namespaces, defaultNamespaces) {
const roles = [];
let idx;
let length;
if (!namespaces[0] && defaultNamespaces) namespaces = defaultNamespaces;
for (idx = 0, length = namespaces.length; idx < length; idx++) roles[idx] = namespaces[idx].roles;
const reversedRoles = [...roles].reverse();
return $.extend.apply(null, [{}].concat(reversedRoles));
}
};
const widgetRegistryService = new WidgetRegistryService();
//#endregion
//#region ../src/core/services/property-access.service.ts
/**
* Property Access Service Implementation
* Provides utilities for dynamic property access using path expressions.
*/
var PropertyAccessService = class {
constructor() {
this.getterCache = {};
this.setterCache = {};
}
/**
* Wrap an expression for safe access.
* Generates nested null-safe property access.
*/
wrapExpression(members, paramName) {
let result = paramName || "d";
let count = 1;
for (let idx = 0; idx < members.length; idx++) {
let member = members[idx];
if (member !== "") {
const index = member.indexOf("[");
if (index !== 0) if (index === -1) member = "." + member;
else {
count++;
member = "." + member.substring(0, index) + " || {})" + member.substring(index);
}
count++;
result += member + (idx < members.length - 1 ? " || {})" : ")");
}
}
return new Array(count).join("(") + result;
}
/**
* Generate a JavaScript expression for accessing a property path.
*/
expr(expression, safe, paramName) {
expression = expression || "";
if (typeof safe === "string") {
paramName = safe;
safe = false;
}
paramName = paramName || "d";
if (expression && expression.charAt(0) !== "[") expression = "." + expression;
if (safe) {
expression = expression.replace(/"([^.]*)\.([^"]*)"/g, "\"$1_$DOT$_$2\"");
expression = expression.replace(/'([^.]*)\.([^']*)'/g, "'$1_$DOT$_$2'");
expression = this.wrapExpression(expression.split("."), paramName);
expression = expression.replace(/_\$DOT\$_/g, ".");
} else expression = paramName + expression;
return expression;
}
/**
* Convert an expression to an array of field names.
*/
exprToArray(expression, safe) {
expression = expression || "";
return expression.indexOf(".") >= 0 || expression.indexOf("[") >= 0 ? expression.split(/[[\].]/).map((v) => v.replace(/["']/g, "")).filter((v) => v) : expression === "" ? [] : [expression];
}
/**
* Create a getter function for a property path.
*/
getter(expression, safe) {
const key = expression + safe;
if (!this.getterCache[key]) this.getterCache[key] = (obj) => {
const fields = this.exprToArray(expression, safe);
let result = obj;
for (let idx = 0; idx < fields.length; idx++) {
result = result[fields[idx]];
if (!utilsService.isPresent(result) && safe) return result;
}
return result;
};
return this.getterCache[key];
}
/**
* Create a setter function for a property path.
*/
setter(expression) {
if (!this.setterCache[expression]) this.setterCache[expression] = (obj, value) => {
const fields = this.exprToArray(expression);
const innerSetter = (args) => {
if (args.props.length) {
args.parent = args.parent[args.props.shift()];
innerSetter(args);
} else args.parent[args.prop] = args.val;
};
innerSetter({
parent: obj,
val: value,
prop: fields.pop(),
props: fields
});
};
return this.setterCache[expression];
}
/**
* Create an accessor with both get and set functions.
*/
accessor(expression) {
return {
get: this.getter(expression),
set: this.setter(expression)
};
}
};
const propertyAccessService = new PropertyAccessService();
//#endregion
//#region ../src/core/services/widget-utils.service.ts
/**
* Widget Utils Service
*
* Provides utilities for widget initialization, lifecycle management, and instance retrieval.
* All methods preserve exact original functionality from kendo.core.js.
*
*/
const STRING$1 = "string";
const FUNCTION = "function";
const templateRegExp = /template$/i;
const jsonRegExp = /^\s*(?:\{(?:.|\r\n|\n)*\}|\[(?:.|\r\n|\n)*\])\s*$/;
const jsonFormatRegExp = /^\{(\d+)(:[^\}]+)?\}|^\[[A-Za-z_]+\]$/;
const dashRegExp = /([A-Z])/g;
const numberRegExp = /^(\+|-?)\d+(\.?)\d*$/;
const cssPropertiesNames = [
"themeColor",
"fillMode",
"shape",
"size",
"rounded",
"positionMode"
];
/**
* Widget Utils Service Implementation
*/
var WidgetUtilsService = class {
/**
* Get default namespaces from the registry service
* Returns [kendo.ui, kendo.dataviz.ui, kendo.mobile.ui]
*/
getDefaultNamespaces() {
return [
widgetRegistryService.getNamespace("ui"),
widgetRegistryService.getNamespace("dataviz.ui"),
widgetRegistryService.getNamespace("mobile.ui")
].filter(Boolean);
}
/**
* Parse a single option from element's data attribute
*/
parseOption(element, option, source) {
const ns = namespaceService.ns;
let value;
let modelBinded = false;
if (option.indexOf("data") === 0) {
option = option.substring(4);
option = option.charAt(0).toLowerCase() + option.substring(1);
}
option = option.replace(dashRegExp, "-$1");
value = element.getAttribute("data-" + ns + option);
if (value === null) {
value = element.getAttribute("bind:data-" + ns + option);
modelBinded = true;
}
if (value === null) value = void 0;
else if (value === "null") value = null;
else if (value === "true") value = true;
else if (value === "false") value = false;
else if (numberRegExp.test(value) && option != "mask" && option != "format") value = parseFloat(value);
else if (jsonRegExp.test(value) && !jsonFormatRegExp.test(value)) try {
value = JSON.parse(value);
} catch (error) {
value = new Function("return (" + value + ")")();
}
else if (modelBinded) {
value = source[value];
if (value instanceof Observable) value = value.toJSON(true);
}
return value;
}
/**
* Parse all options from element's data attributes
*/
parseOptions(element, options, source) {
const ns = namespaceService.ns;
const result = {};
let option;
let value;
const role = element.getAttribute("data-" + ns + "role");
const allOptions = Object.keys(options);
for (let i = 0; i < cssPropertiesNames.length; i++) if (allOptions.indexOf(cssPropertiesNames[i]) === -1) allOptions.push(cssPropertiesNames[i]);
for (let i = 0; i < allOptions.length; i++) {
option = allOptions[i];
value = this.parseOption(element, option, source);
if (value !== void 0) {
if (templateRegExp.test(option) && role != "drawer") {
if (typeof value === "string") if (this.validateQuerySelectorTemplate(value)) value = templateService.compile($("#" + value).html());
else if (source && source[value]) value = templateService.compile(source[value]);
else value = templateService.compile(value);
else if (!utilsService.isFunction(value)) value = element.getAttribute(option);
}
result[option] = value;
}
}
return result;
}
/**
* Validate if a value is a valid query selector for a template element
*/
validateQuerySelectorTemplate(value) {
try {
return !!$("#" + value).length;
} catch (e) {}
return false;
}
/**
* Initialize a widget on an element
*/
initWidget(element, options, roles, source) {
const ns = namespaceService.ns;
let result;
let option;
let widget;
let idx;
let length;
let role;
let value;
let dataSource;
let fullPath;
let widgetKeyRegExp;
if (!roles) roles = this.getDefaultNamespaces()[0].roles;
else if (roles.roles) roles = roles.roles;
element = element.nodeType ? element : element[0];
role = element.getAttribute("data-" + ns + "role");
if (!role) return;
fullPath = role.indexOf(".") === -1;
if (fullPath) widget = roles[role];
else widget = propertyAccessService.getter(role)(window);
const data = $(element).data();
const widgetKey = widget ? "kendo" + widget.fn.options.prefix + widget.fn.options.name : "";
if (fullPath) widgetKeyRegExp = new RegExp("^kendo.*" + role + "$", "i");
else widgetKeyRegExp = new RegExp("^" + widgetKey + "$", "i");
for (var key in data) if (key.match(widgetKeyRegExp)) if (key === widgetKey) result = data[key];
else return data[key];
if (!widget) return;
dataSource = this.parseOption(element, "dataSource");
options = $.extend({}, this.parseOptions(element, $.extend({}, widget.fn.options, widget.fn.defaults), source), options);
if (dataSource) if (typeof dataSource === STRING$1) options.dataSource = propertyAccessService.getter(dataSource)(window);
else options.dataSource = dataSource;
for (idx = 0, length = widget.fn.events.length; idx < length; idx++) {
option = widget.fn.events[idx];
value = this.parseOption(element, option);
if (value !== void 0) options[option] = propertyAccessService.getter(value)(window);
}
if (!result) result = new widget(element, options);
else if (!$.isEmptyObject(options)) result.setOptions(options);
return result;
}
/**
* Initialize all widgets in an element tree
*/
init(element, ...namespaces) {
const ns = namespaceService.ns;
const roles = widgetRegistryService.rolesFromNamespaces(namespaces, this.getDefaultNamespaces());
const self = this;
$(element).find("[data-" + ns + "role]").addBack().each(function() {
self.initWidget(this, {}, roles);
});
}
/**
* Destroy all widgets in an element tree
*/
destroy(element) {
const ns = namespaceService.ns;
$(element).find("[data-" + ns + "role]").addBack().each(function() {
const data = $(this).data();
for (var key in data) if (key.indexOf("kendo") === 0 && typeof data[key].destroy === FUNCTION) data[key].destroy();
});
}
/**
* Containment comparer for sorting widgets by DOM hierarchy
*/
containmentComparer(a, b) {
return $.contains(a, b) ? -1 : 1;
}
/**
* Resize all widgets in an element tree
*/
resize(element, force) {
const ns = namespaceService.ns;
const self = this;
const resizableWidgetFilter = function() {
const widget = $(this);
return $.inArray(widget.attr("data-" + ns + "role"), [
"slider",
"rangeslider",
"breadcrumb"
]) > -1 || widget.is(":visible");
};
const widgets = $(element).find("[data-" + ns + "role]").addBack().filter(resizableWidgetFilter);
if (!widgets.length) return;
const widgetsArray = $.makeArray(widgets);
widgetsArray.sort((a, b) => self.containmentComparer(a, b));
$.each(widgetsArray, function() {
const widget = self.widgetInstance($(this));
if (widget) widget.resize(force);
});
}
/**
* Get widget instance from a DOM element
*/
widgetInstance(element, suites) {
const ns = namespaceService.ns;
const defaultNamespaces = this.getDefaultNamespaces();
let role = element.data(ns + "role");
let widgets = [];
let i;
let length;
const elementData = element.data("kendoView");
if (role) {
if (role === "content") role = "scroller";
if (role === "view" && elementData) return elementData;
if (suites) if (suites[0]) for (i = 0, length = suites.length; i < length; i++) widgets.push(suites[i].roles[role]);
else widgets.push(suites.roles[role]);
else widgets = defaultNamespaces.map((ns) => ns.roles[role]);
if (role.indexOf(".") >= 0) widgets = [propertyAccessService.getter(role)(window)];
for (i = 0, length = widgets.length; i < length; i++) {
const widget = widgets[i];
if (widget) {
const instance = element.data("kendo" + widget.fn.options.prefix + widget.fn.options.name);
if (instance) return instance;
}
}
}
}
};
const widgetUtilsService = new WidgetUtilsService();
//#endregion
//#region ../src/core/services/focus-utils.service.ts
const TAB_KEY = 9;
/**
* Focus Utils Service - provides focus-related utilities
*/
var FocusUtilsService = class {
/**
* Check if an element is focusable
*/
focusable(element, isTabIndexNotNaN) {
const nodeName = element.nodeName.toLowerCase();
return (/input|select|textarea|button|object/.test(nodeName) ? !element.disabled : nodeName === "a" ? element.href || isTabIndexNotNaN : isTabIndexNotNaN) && this.visible(element);
}
/**
* Check if an element is visible (not hidden or with visibility:hidden)
*/
visible(element) {
return $.expr.pseudos.visible(element) && !$(element).parents().addBack().filter(function() {
return $.css(this, "visibility") === "hidden";
}).length;
}
/**
* Check if an element is kendo-focusable (focusable with positive tabindex)
*/
kendoFocusable(element) {
const idx = $(element).attr("tabindex");
const numIdx = idx !== void 0 ? parseInt(idx, 10) : NaN;
return this.focusable(element, !isNaN(numIdx) && numIdx > -1);
}
/**
* Focus an element while preserving scroll positions of parent containers
*/
focusElement(element) {
const domUtils = domUtilsService;
const scrollTopPositions = [];
const scrollableParents = element.parentsUntil("body").filter(function(index, el) {
return domUtils.getComputedStyles(el, ["overflow"]).overflow !== "visible";
}).add(window);
scrollableParents.each(function(index, parent) {
scrollTopPositions[index] = $(parent).scrollTop() || 0;
});
try {
element[0].setActive();
} catch (e) {
element.trigger("focus");
}
scrollableParents.each(function(index, parent) {
$(parent).scrollTop(scrollTopPositions[index]);
});
}
/**
* Focus the next focusable element in the document
*/
focusNextElement() {
if (document.activeElement) {
const focussable = $(":kendoFocusable");
const index = focussable.index(document.activeElement);
if (index > -1) (focussable[index + 1] || focussable[0]).focus();
}
}
/**
* Set up form cycling - when tabbing from last element, cycle to first
*/
cycleForm(form) {
const firstElement = form.find("input, .k-widget, .k-dropdownlist, .k-combobox").first();
const lastElement = form.find("button, .k-button").last();
function focus(el) {
const widget = widgetUtilsService.widgetInstance(el);
if (widget && widget.focus) widget.focus();
else el.trigger("focus");
}
lastElement.on("keydown", function(e) {
if (e.keyCode === TAB_KEY && !e.shiftKey) {
e.preventDefault();
focus(firstElement);
}
});
firstElement.on("keydown", function(e) {
if (e.keyCode === TAB_KEY && e.shiftKey) {
e.preventDefault();
focus(lastElement);
}
});
}
/**
* Get the focusable element for a widget
*/
getWidgetFocusableElement(element) {
const nextFocusable = element.closest(":kendoFocusable");
const widgetInstance = widgetUtilsService.widgetInstance(element);
let target;
if (nextFocusable.length) target = nextFocusable;
else if (widgetInstance) target = widgetInstance.options.name === "Editor" ? $(widgetInstance.body) : widgetInstance.wrapper.find(":kendoFocusable").first();
else target = element;
return target;
}
/**
* Register the :kendoFocusable pseudo-selector with jQuery
*/
registerFocusableSelector() {
const self = this;
$.extend($.expr.pseudos, { kendoFocusable: function(element) {
return self.kendoFocusable(element);
} });
}
/**
* Get the currently focused element in the document.
* Handles exceptions that can occur in some browsers.
* @returns The active element
*/
activeElement() {
try {
return document.activeElement;
} catch (e) {
return document.documentElement.activeElement;
}
}
};
const focusUtilsService = new FocusUtilsService();
//#endregion
//#region ../src/core/services/color.service.ts
/**
* Color Service Implementation
* Provides utilities for extracting theme colors.
*/
var ColorService = class {
/**
* Get series colors from CSS custom properties.
*/
getSeriesColors() {
const series = $("<div class=\"k-var--series-a\"></div><div class=\"k-var--series-b\"></div><div class=\"k-var--series-c\"></div><div class=\"k-var--series-d\"></div><div class=\"k-var--series-e\"></div><div class=\"k-var--series-f\"></div>");
const colors = [];
series.appendTo($("body"));
series.each((_i, item) => {
colors.push($(item).css("background-color"));
});
series.remove();
return colors;
}
};
const colorService = new ColorService();
//#endregion
//#region ../src/core/services/selector.service.ts
/**
* Selector Service Implementation
* Provides utilities for building CSS selectors.
*/
var SelectorService = class {
/**
* Convert space-separated class names to a CSS selector.
*/
selectorFromClasses(classes) {
return "." + classes.split(" ").join(".");
}
/**
* Build a role selector for data-role attributes.
*/
roleSelector(role, ns) {
return role.replace(/(\S+)/g, "[data-" + ns + "role=$1],").slice(0, -1);
}
/**
* Build a directive selector for mobile components.
*/
directiveSelector(directives) {
const selectors = directives.split(" ");
if (selectors) {
for (let i = 0; i < selectors.length; i++) if (selectors[i] !== "view") selectors[i] = selectors[i].replace(/(\w*)(view|bar|strip|over)$/, "$1-$2");
}
return selectors.join(" ").replace(/(\S+)/g, "kendo-mobile-$1,").slice(0, -1);
}
};
const selectorService = new SelectorService();
//#endregion
//#region ../src/core/services/timezone.service.ts
const NUMBER = "number";
const STRING = "string";
/**
* Service for timezone conversions
*/
var TimezoneService = class {
constructor() {
this.zones = {};
this.rules = {};
this.months = {
Jan: 0,
Feb: 1,
Mar: 2,
Apr: 3,
May: 4,
Jun: 5,
Jul: 6,
Aug: 7,
Sep: 8,
Oct: 9,
Nov: 10,
Dec: 11
};
this.days = {
Sun: 0,
Mon: 1,
Tue: 2,
Wed: 3,
Thu: 4,
Fri: 5,
Sat: 6
};
}
/**
* Get the UTC offset for a given time in a timezone
*/
offset(utcTime, timezone) {
if (timezone === "Etc/UTC" || timezone === "Etc/GMT") return 0;
const info = this.zoneAndRule(utcTime, this.zones, this.rules, timezone);
const zone = info.zone;
const rule = info.rule;
return numberParserService.parseFloat(rule ? zone[0] - rule[6] : zone[0]);
}
/**
* Get the timezone abbreviation for a given time
*/
abbr(utcTime, timezone) {
const info = this.zoneAndRule(utcTime, this.zones, this.rules, timezone);
const zone = info.zone;
const rule = info.rule;
const base = zone[2];
if (base.indexOf("/") >= 0) return base.split("/")[rule && +rule[6] ? 1 : 0];
else if (base.indexOf("%s") >= 0) return base.replace("%s", !rule || rule[7] === "-" ? "" : rule[7]);
return base;
}
/**
* Convert a date between timezones
*/
convert(date, fromOffset, toOffset) {
let tempToOffset = toOffset;
let diff;
if (typeof fromOffset === STRING) fromOffset = this.offset(date, fromOffset);
if (typeof toOffset === STRING) toOffset = this.offset(date, toOffset);
const fromLocalOffset = date.getTimezoneOffset();
date = new Date(date.getTime() + (fromOffset - toOffset) * 6e4);
const toLocalOffset = date.getTimezoneOffset();
if (typeof tempToOffset === STRING) tempToOffset = this.offset(date, tempToOffset);
diff = toLocalOffset - fromLocalOffset + (toOffset - tempToOffset);
return new Date(date.getTime() + diff * 6e4);
}
/**
* Apply a timezone to a local date
*/
apply(date, timezone) {
return this.convert(date, date.getTimezoneOffset(), timezone);
}
/**
* Remove timezone adjustment from a date
*/
remove(date, timezone) {
return this.convert(date, timezone, date.getTimezoneOffset());
}
/**
* Convert a UTC timestamp to a local date
*/
toLocalDate(time) {
return this.apply(new Date(time), "Etc/UTC");
}
/**
* Convert a rule to a Date for a specific year
*/
ruleToDate(year, rule) {
let date;
let targetDay;
let ourDay;
const month = rule[3];
const on = rule[4];
const time = rule[5];
let cache = rule[8];
if (!cache) rule[8] = cache = {};
if (cache[year]) return cache[year];
if (!isNaN(on)) date = new Date(Date.UTC(year, this.months[month], on, time[0], time[1], time[2], 0));
else if (on.indexOf("last") === 0) {
date = new Date(Date.UTC(year, this.months[month] + 1, 1, time[0] - 24, time[1], time[2], 0));
targetDay = this.days[on.substr(4, 3)];
ourDay = date.getUTCDay();
date.setUTCDate(date.getUTCDate() + targetDay - ourDay - (targetDay > ourDay ? 7 : 0));
} else if (on.indexOf(">=") >= 0) {
date = new Date(Date.UTC(year, this.months[month], parseInt(on.substr(5), 10), time[0], time[1], time[2], 0));
targetDay = this.days[on.substr(0, 3)];
ourDay = date.getUTCDay();
date.setUTCDate(date.getUTCDate() + targetDay - ourDay + (targetDay < ourDay ? 7 : 0));
} else if (on.indexOf("<=") >= 0) {
date = new Date(Date.UTC(year, this.months[month], parseInt(on.substr(5), 10), time[0], time[1], time[2], 0));
targetDay = this.days[on.substr(0, 3)];
ourDay = date.getUTCDay();
date.setUTCDate(date.getUTCDate() + targetDay - ourDay - (targetDay > ourDay ? 7 : 0));
}
return cache[year] = date;
}
/**
* Find the applicable rule for a given UTC time
*/
findRule(utcTime, rules, zone) {
let zoneRules = rules[zone];
if (!zoneRules) {
const time = zone.split(":");
let offset = 0;
if (time.length > 1) offset = parseInt(time[0], 10) * 60 + Number(time[1]);
return [
-1e6,
"max",
"-",
"Jan",
1,
[
0,
0,
0
],
offset,
"-"
];
}
const year = new Date(utcTime).getUTCFullYear();
zoneRules = zoneRules.filter((rule) => {
const from = rule[0];
const to = rule[1];
return from <= year && (to >= year || from == year && to === "only" || to === "max");
});
const sortArray = [...zoneRules, utcTime];
sortArray.sort((a, b) => {
let aVal = a;
let bVal = b;
if (typeof a !== "number") aVal = Number(this.ruleToDate(year, a));
if (typeof b !== "number") bVal = Number(this.ruleToDate(year, b));
return aVal - bVal;
});
const rule = sortArray[sortArray.indexOf(utcTime) - 1] || sortArray[sortArray.length - 1];
return isNaN(rule) ? rule : null;
}
/**
* Find the zone definition for a given UTC time
*/
findZone(utcTime, zones, timezone) {
let zoneRules = zones[timezone];
if (typeof zoneRules === "string") zoneRules = zones[zoneRules];
if (!zoneRules) throw new Error("Timezone \"" + timezone + "\" is either incorrect, or kendo.timezones.min.js is not included.");
const zoneArray = zoneRules;
let idx;
for (idx = zoneArray.length - 1; idx >= 0; idx--) {
const until = zoneArray[idx][3];
if (until && utcTime > until) break;
}
const zone = zoneArray[idx + 1];
if (!zone) throw new Error("Timezone \"" + timezone + "\" not found on " + utcTime + ".");
return zone;
}
/**
* Get zone and rule info for a given UTC time
*/
zoneAndRule(utcTime, zones, rules, timezone) {
if (typeof utcTime !== NUMBER) {
const date = utcTime;
utcTime = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
}
const zone = this.findZone(utcTime, zones, timezone);
return {
zone,
rule: this.findRule(utcTime, rules, zone[1])
};
}
};
const timezoneService = new TimezoneService();
//#endregion
//#region ../src/core/services/type-utils.service.ts
/**
* Service for runtime type checking utilities.
* Provides type() function that was deprecated in jQuery.
*/
var TypeUtilsService = class {
constructor() {
this.class2type = {};
"Boolean Number String Function Array Date RegExp Object Error Symbol".split(" ").forEach((name) => {
this.class2type["[object " + name + "]"] = name.toLowerCase();
});
}
/**
* Get the class2type mapping object
*/
getClass2Type() {
return this.class2type;
}
/**
* Determine the internal JavaScript [[Class]] of an object.
* This is a replacement for jQuery.type() which was deprecated.
*
* @param obj - The object to get the type of
* @returns The type name as a lowercase string (e.g., "string", "number", "array", "date", "regexp", "object", "null", "undefined")
*
* @example
* ```typescript
* type(undefined) // "undefined"
* type(null) // "null"
* type(true) // "boolean"
* type(3) // "number"
* type("test") // "string"
* type(function(){}) // "function"
* type([]) // "array"
* type(new Date()) // "date"
* type(/test/) // "regexp"
* type({}) // "object"
* ```
*/
type(obj) {
if (obj == null) return obj + "";
return typeof obj === "object" || typeof obj === "function" ? this.class2type[Object.prototype.toString.call(obj)] || "object" : typeof obj;
}
};
const typeUtilsService = new TypeUtilsService();
//#endregion
//#region ../src/core/services/defaults.service.ts
/**
* Defaults Service
* Manages global Kendo defaults configuration with deep path support.
*/
/**
* Service for managing global Kendo defaults configuration.
* Supports deep path-based setting with automatic object creation.
*/
var DefaultsService = class {
constructor() {
this.defaults = {};
}
/**
* Get the current defaults object
*/
getDefaults() {
return this.defaults;
}
/**
* Set a default value at a given path.
* Supports dot-separated paths for nested values.
* Objects are deep extended, primitives are replaced.
*
* @param key - Dot-separated path (e.g., "breakpoints", "grid.pager.pageSize")
* @param value - The value to set at the path
*
* @example
* ```typescript
* // Set a simple value
* setDefaults('pageSize', 10);
*
* // Set a nested value
* setDefaults('grid.pager.pageSize', 20);
*
* // Deep extend an object
* setDefaults('breakpoints', { sm: 576, md: 768 });
* ```
*/
setDefaults(key, value) {
const path = key.split(".");
let curr = this.defaults;
key = path.pop();
path.forEach((part) => {
if (curr[part] === void 0) curr[part] = {};
curr = curr[part];
});
if (value !== null && typeof value === "object" && value.constructor === Object) curr[key] = utilsService.deepExtend({}, curr[key] || {}, value);
else curr[key] = value;
}
/**
* Get a default value at a given path.
*
* @param key - Dot-separated path (e.g., "breakpoints", "grid.pager.pageSize")
* @returns The value at the path, or undefined if not found
*/
getDefault(key) {
const path = key.split(".");
let curr = this.defaults;
for (const part of path) {
if (curr[part] === void 0) return;
curr = curr[part];
}
return curr;
}
};
const defaultsService = new DefaultsService();
let $$1 = window.jQuery || window.$ || jQuery;
const kendo$1 = window.kendo = window.kendo || { cultures: {} };
const extend = $$1.extend;
const each = $$1.each;
const noop = $$1.noop;
const slice = [].slice;
if (!window.KendoLicensing) window.KendoLicensing = { setScriptKey: _progress_kendo_licensing.setScriptKey };
kendo$1.version = packageMetadata.version;
const EN = "en-US";
const kendoJQuery = kendoJQueryService.getConstructor();
const eventMap = eventMapService.getFullEventMap();
const Template = {
get paramName() {
return templateService.paramName;
},
set paramName(value) {
templateService.paramName = value;
},
get useWithBlock() {
return templateService.useWithBlock;
},
set useWithBlock(value) {
templateService.useWithBlock = value;
},
render: function(template, data) {
return templateService.render(template, data);
},
compile: function(template, options) {
return templateService.compile(template, options);
}
};
kendo$1.jQuery = kendoJQuery;
kendo$1.eventMap = eventMap;
kendo$1.ConvertClass = fromESClass;
kendo$1.createProxyMember = function(proto, name) {
return utilsService.createProxyMember(proto, name);
};
kendo$1.getBaseClass = function(targetClass) {
return utilsService.getBaseClass(targetClass);
};
kendo$1.getAllMethods = function(targetClass) {
return utilsService.getAllMethods(targetClass);
};
kendo$1.convertPromiseToDeferred = function(promise) {
return utilsService.convertPromiseToDeferred(promise);
};
kendo$1.throttle = function(fn, delay) {
return utilsService.throttle(fn, delay);
};
kendo$1.trim = function(value) {
return utilsService.trim(value);
};
kendo$1.whenAll = function(array) {
return utilsService.whenAll(array);
};
kendo$1.days = utilsService.days;
kendo$1.isPresent = (value) => utilsService.isPresent(value);
kendo$1.isBlank = (value) => utilsService.isBlank(value);
kendo$1.isEmpty = (value) => utilsService.isEmpty(value);
kendo$1.isString = (value) => utilsService.isString(value);
kendo$1.isInteger = (value) => utilsService.isInteger(value);
kendo$1.isNumeric = (value) => utilsService.isNumeric(value);
kendo$1.isDate = (value) => utilsService.isDate(value);
kendo$1.isFunction = (value) => utilsService.isFunction(value);
function deepExtend(destination) {
const sources = Array.prototype.slice.call(arguments, 1);
return utilsService.deepExtend(destination, ...sources);
}
function toHyphens(str) {
return utilsService.toHyphens(str);
}
function toCamelCase(str) {
return utilsService.toCamelCase(str);
}
function size(obj) {
return utilsService.size(obj);
}
function htmlEncode(value, shouldDecode) {
return htmlService.encode(value, shouldDecode);
}
function sanitizeLink(value) {
return htmlService.sanitizeLink(value);
}
function unescape(value) {
return htmlService.unescape(value);
}
function convertTextUrlToLink(text, skipSanitization) {
return htmlService.convertTextUrlToLink(text, skipSanitization);
}
function findCulture(culture) {
return cultureService.findCulture(culture);
}
function getCulture(culture) {
return cultureService.getCulture(culture);
}
kendo$1.culture = function(cultureName) {
if (cultureName !== void 0) cultureService.setCulture(cultureName);
else return cultureService.culture();
};
kendo$1.findCulture = findCulture;
kendo$1.getCulture = getCulture;
kendo$1.kendoCultureToIntl = function(culture) {
return intlService.convert(culture);
};
kendo$1.culture(EN);
const round = function(value, precision, negative) {
return formatterService.round(value, precision, negative);
};
const toString = function(value, fmt, culture) {
return formatterService.toString(value, fmt, culture);
};
kendo$1.format = function(fmt) {
const values = Array.prototype.slice.call(arguments, 1);
return formatterService.format(fmt, ...values);
};
kendo$1._extractFormat = function(format) {
return formatterService.extractFormat(format);
};
kendo$1._round = round;
kendo$1.dimensions = function(element, dimensions) {
return domUtilsService.dimensions(element, dimensions);
};
kendo$1.onResize = function(callback) {
return domUtilsService.onResize(callback);
};
kendo$1.unbindResize = function(callback) {
domUtilsService.unbindResize(callback);
};
kendo$1.attrValue = function(element, key) {
return domUtilsService.attrValue(element, key);
};
kendo$1.stripWhitespace = function(element) {
domUtilsService.stripWhitespace(element);
};
kendo$1.animationFrame = function(callback) {
domUtilsService.animationFrame(callback);
};
kendo$1.queueAnimation = function(callback) {
domUtilsService.queueAnimation(callback);
};
kendo$1.runNextAnimation = function() {
domUtilsService.runNextAnimation();
};
kendo$1.parseQueryStringParams = function(url) {
return domUtilsService.parseQueryStringParams(url);
};
kendo$1.elementUnderCursor = function(e) {
return domUtilsService.elementUnderCursor(e);
};
kendo$1.wheelDeltaY = function(jQueryEvent) {
return domUtilsService.wheelDeltaY(jQueryEvent);
};
kendo$1.addAttribute = function(element, attribute, value) {
return domUtilsService.addAttribute(element, attribute, value);
};
kendo$1.removeAttribute = function(element, attribute) {
return domUtilsService.removeAttribute(element, attribute);
};
kendo$1.toggleAttribute = function(element, attribute, value) {
return domUtilsService.toggleAttribute(element, attribute, value);
};
kendo$1.applyStylesFromKendoAttributes = function(element, styleProps) {
return domUtilsService.applyStylesFromKendoAttributes(element, styleProps);
};
kendo$1.isElement = function(element) {
return domUtilsService.isElement(element);
};
kendo$1._outerWidth = function(element, includeMargin, calculateFromHidden) {
return domUtilsService.outerWidth(element, includeMargin, calculateFromHidden);
};
kendo$1._outerHeight = function(element, includeMargin, calculateFromHidden) {
return domUtilsService.outerHeight(element, includeMargin, calculateFromHidden);
};
kendo$1.getShadows = function(element) {
return domUtilsService.getShadows(element);
};
kendo$1.wrap = function(element, autosize, resize, shouldCorrectWidth = true, autowidth) {
return domUtilsService.wrap(element, autosize, resize, shouldCorrectWidth, autowidth);
};
function getComputedStyles(element, properties) {
return domUtilsService.getComputedStyles(element, properties);
}
function isScrollable(element) {
return domUtilsService.isScrollable(element);
}
function scrollLeft(element, value) {
return domUtilsService.scrollLeft(element, value);
}
function getOffset(element, type, positioned) {
return domUtilsService.getOffset(element, type, positioned);
}
function parseEffects(input) {
return domUtilsService.parseEffects(input);
}
kendo$1.toString = toString;
kendo$1.parseDate = function(value, formats, culture, shouldUnpadZeros) {
return dateParserService.parseDate(value, formats, culture, shouldUnpadZeros);
};
kendo$1.parseExactDate = function(value, formats, culture) {
return dateParserService.parseExactDate(value, formats, culture);
};
kendo$1.parseInt = function(value, culture) {
return numberParserService.parseInt(value, culture);
};
kendo$1.parseFloat = function(value, culture, format) {
return numberParserService.parseFloat(value, culture, format);
};
(function() {
let timezoneWired = false;
let originalTimezone;
Object.defineProperty(kendo$1, "timezone", {
get: function() {
return originalTimezone;
},
set: function(value) {
originalTimezone = value;
if (value && !timezoneWired) {
dateParserService.setTimezoneService(value);
timezoneWired = true;
}
},
configurable: true
});
})();
const directions = effectsService.directions;
function fx(element) {
return effectsService.fx(element);
}
const effects = effectsService.effects;
function animate(element, options, duration, reverse, complete) {
return effectsService.animate(element, options, duration, reverse, complete);
}
function toggleClass(element, classes, options, add) {
return effectsService.toggleClass(element, classes, options, add);
}
if (!("kendoAnimate" in $$1.fn)) extend($$1.fn, {
kendoStop: function(clearQueue, gotoEnd) {
return this.stop(clearQueue, gotoEnd);
},
kendoAnimate: function(options, duration, reverse, complete) {
return animate(this, options, duration, reverse, complete);
},
kendoAddClass: function(classes, options) {
return kendo$1.toggleClass(this, classes, options, true);
},
kendoRemoveClass: function(classes, options) {
return kendo$1.toggleClass(this, classes, options, false);
},
kendoToggleClass: function(classes, options, toggle) {
return kendo$1.toggleClass(this, classes, options, toggle);
}
});
const eventTarget = function(e) {
return domUtilsService.eventTarget(e);
};
if (supportService.touch) each([
"swipe",
"swipeLeft",
"swipeRight",
"swipeUp",
"swipeDown",
"doubleTap",
"tap"
], function(m, value) {
$$1.fn[value] = function(callback) {
return this.on(value, callback);
};
});
extend(kendo$1, {
ui: kendo$1.ui || {},
fx: kendo$1.fx || fx,
effects: kendo$1.effects || effects,
mobile: kendo$1.mobile || {},
data: kendo$1.data || {},
dataviz: kendo$1.dataviz || {},
drawing: kendo$1.drawing || {},
spreadsheet: { messages: {} },
keys: utilsService.keys,
support: kendo$1.support || supportService,
animate: kendo$1.animate || animate,
attr: function(value) {
return domUtilsService.attr(value);
},
deepExtend,
getComputedStyles,
isScrollable,
scrollLeft,
size,
toCamelCase,
toHyphens,
getOffset: kendo$1.getOffset || getOffset,
parseEffects: kendo$1.parseEffects || parseEffects,
toggleClass: kendo$1.toggleClass || toggleClass,
directions: kendo$1.directions || directions,
Observable,
Class,
Template,
template: Template.compile.bind(Template),
render: Template.render.bind(Template),
stringify: JSON.stringify.bind(JSON),
eventTarget,
htmlEncode,
sanitizeLink,
convertTextUrlToLink,
unescape,
isLocalUrl: function(url) {
return utilsService.isLocalUrl(url);
},
mediaQuery,
expr: function(expression, safe, paramName) {
return propertyAccessService.expr(expression, safe, paramName);
},
exprToArray: function(expression, safe) {
return propertyAccessService.exprToArray(expression, safe);
},
getter: function(expression, safe) {
return propertyAccessService.getter(expression, safe);
},
setter: function(expression) {
return propertyAccessService.setter(expression);
},
accessor: function(expression) {
return propertyAccessService.accessor(expression);
},
guid: function() {
return utilsService.guid();
},
roleSelector: function(role) {
return selectorService.roleSelector(role, namespaceService.ns);
},
directiveSelector: function(directives) {
return selectorService.directiveSelector(directives);
},
triggeredByInput: function(e) {
return domUtilsService.triggeredByInput(e);
},
logToConsole: function(message, type) {
utilsService.logToConsole(message, type);
}
});
Object.defineProperty(kendo$1, "ns", {
get: function() {
return namespaceService.ns;
},
set: function(value) {
namespaceService.setNs(value);
},
enumerable: true,
configurable: true
});
kendo$1.notify = noop;
kendo$1.initWidget = function(element, options, roles, source) {
return widgetUtilsService.initWidget(element, options, roles, source);
};
kendo$1.rolesFromNamespaces = function(namespaces) {
return widgetRegistryService.rolesFromNamespaces(namespaces, [kendo$1.ui, kendo$1.dataviz.ui]);
};
kendo$1.init = function(element) {
const namespaces = slice.call(arguments, 1);
widgetUtilsService.init(element, ...namespaces);
};
kendo$1.destroy = function(element) {
widgetUtilsService.destroy(element);
};
kendo$1.resize = function(element, force) {
widgetUtilsService.resize(element, force);
};
kendo$1.parseOptions = function(element, options, source) {
return widgetUtilsService.parseOptions(element, options, source);
};
const ContainerNullObject = {
bind: function() {
return this;
},
nullObject: true,
options: {}
};
const MobileWidget = Widget.extend({
init: function(element, options) {
Widget.fn.init.call(this, element, options);
this.element.autoApplyNS();
this.wrapper = this.element;
this.element.addClass("km-widget");
},
destroy: function() {
Widget.fn.destroy.call(this);
this.element.kendoDestroy();
},
options: { prefix: "Mobile" },
events: [],
view: function() {
const viewElement = this.element.closest(kendo$1.roleSelector("view splitview modalview drawer"));
return widgetUtilsService.widgetInstance(viewElement, kendo$1.mobile.ui) || ContainerNullObject;
},
viewHasNativeScrolling: function() {
const view = this.view();
return view && view.options.useNativeScrolling;
},
container: function() {
const element = this.element.closest(kendo$1.roleSelector("view layout modalview drawer splitview"));
return widgetUtilsService.widgetInstance(element.eq(0), kendo$1.mobile.ui) || ContainerNullObject;
}
});
kendo$1.ui = widgetRegistryService.createNamespace("ui", {
Widget,
DataBoundWidget,
progress: function(container, toggle, options) {
return domUtilsService.progress(container, toggle, options);
},
plugin: function(widget, register, prefix) {
widgetRegistryService.registerToNamespace(widget, register || kendo$1.ui, prefix);
}
});
kendo$1.ui.progress.messages = { loading: "Loading..." };
kendo$1.mobile.ui = widgetRegistryService.createNamespace("mobile.ui", {
Widget: MobileWidget,
DataBoundWidget: DataBoundWidget.extend(MobileWidget.prototype),
plugin: function(widget) {
widgetRegistryService.registerToNamespace(widget, kendo$1.mobile.ui, "Mobile");
}
});
extend(kendo$1.mobile, {
init: function(element) {
const defaultNs = widgetRegistryService.getNamespace("ui");
const mobileNs = widgetRegistryService.getNamespace("mobile.ui");
const datavizNs = widgetRegistryService.getNamespace("dataviz.ui");
widgetUtilsService.init(element, mobileNs, defaultNs, datavizNs);
},
roles: {}
});
kendo$1.dataviz.ui = widgetRegistryService.createNamespace("dataviz.ui", {
themes: {},
views: [],
plugin: function(widget) {
widgetRegistryService.registerToNamespace(widget, kendo$1.dataviz.ui);
}
});
deepExtend(kendo$1.dataviz, {
init: function(element) {
widgetUtilsService.init(element, widgetRegistryService.getNamespace("dataviz.ui"));
},
roles: {}
});
kendo$1.touchScroller = function(elements, options) {
if (!options) options = {};
options.useNative = true;
return $$1(elements).map(function(idx, element) {
element = $$1(element);
if (supportService.kineticScrollNeeded && kendo$1.mobile.ui.Scroller && !element.data("kendoMobileScroller")) {
element.kendoMobileScroller(options);
return element.data("kendoMobileScroller");
} else return false;
})[0];
};
kendo$1.preventDefault = function(e) {
e.preventDefault();
};
kendo$1.widgetInstance = function(element, suites) {
return widgetUtilsService.widgetInstance(element, suites);
};
kendo$1.applyEventMap = function(events, ns) {
return eventMapService.applyEventMap(events, ns);
};
kendo$1.keyDownHandler = function(e, widget) {
return kendoJQueryService.keyDownHandler(e, widget);
};
kendo$1.timezone = {
get zones() {
return timezoneService.zones;
},
set zones(value) {
timezoneService.zones = value;
},
get rules() {
return timezoneService.rules;
},
set rules(value) {
timezoneService.rules = value;
},
offset: function(utcTime, timezone) {
return timezoneService.offset(utcTime, timezone);
},
convert: function(date, fromOffset, toOffset) {
return timezoneService.convert(date, fromOffset, toOffset);
},
apply: function(date, timezone) {
return timezoneService.apply(date, timezone);
},
remove: function(date, timezone) {
return timezoneService.remove(date, timezone);
},
abbr: function(utcTime, timezone) {
return timezoneService.abbr(utcTime, timezone);
},
toLocalDate: function(time) {
return timezoneService.toLocalDate(time);
}
};
kendo$1.date = {
get MS_PER_MINUTE() {
return dateUtilsService.MS_PER_MINUTE;
},
get MS_PER_HOUR() {
return dateUtilsService.MS_PER_HOUR;
},
get MS_PER_DAY() {
return dateUtilsService.MS_PER_DAY;
},
adjustDST: function(date, hours) {
return dateUtilsService.adjustDST(date, hours);
},
setDayOfWeek: function(date, day, dir) {
return dateUtilsService.setDayOfWeek(date, day, dir);
},
dayOfWeek: function(date, day, dir) {
return dateUtilsService.dayOfWeek(date, day, dir);
},
firstDayOfMonth: function(date) {
return dateUtilsService.firstDayOfMonth(date);
},
lastDayOfMonth: function(date) {
return dateUtilsService.lastDayOfMonth(date);
},
firstDayOfYear: function(date) {
return dateUtilsService.firstDayOfYear(date);
},
lastDayOfYear: function(date) {
return dateUtilsService.lastDayOfYear(date);
},
weekInYear: function(date, weekStartDay) {
return dateUtilsService.weekInYear(date, weekStartDay);
},
getDate: function(date) {
return dateUtilsService.getDate(date);
},
toUtcTime: function(date) {
return dateUtilsService.toUtcTime(date);
},
getMilliseconds: function(date) {
return dateUtilsService.getMilliseconds(date);
},
isInTimeRange: function(value, min, max) {
return dateUtilsService.isInTimeRange(value, min, max);
},
isInDateRange: function(value, min, max) {
return dateUtilsService.isInDateRange(value, min, max);
},
addDays: function(date, offset) {
return dateUtilsService.addDays(date, offset);
},
setTime: function(date, milliseconds, ignoreDST) {
return dateUtilsService.setTime(date, milliseconds, ignoreDST);
},
setHours: function(date, time) {
return dateUtilsService.setHours(date, time);
},
today: function() {
return dateUtilsService.today();
},
isToday: function(date) {
return dateUtilsService.isToday(date);
},
toInvariantTime: function(date) {
return dateUtilsService.toInvariantTime(date);
},
nextDay: function(date) {
return dateUtilsService.nextDay(date);
},
previousDay: function(date) {
return dateUtilsService.previousDay(date);
},
nextYear: function(date) {
return dateUtilsService.nextYear(date);
},
previousYear: function(date) {
return dateUtilsService.previousYear(date);
},
splitDateFormat: function(format) {
return dateUtilsService.splitDateFormat(format);
},
dateFormatNames: function(options) {
return dateUtilsService.dateFormatNames(options);
},
dateFieldName: function(options) {
return dateUtilsService.dateFieldName(options);
}
};
kendo$1.caret = function(element, start, end) {
return inputService.caret(element, start, end);
};
kendo$1.antiForgeryTokens = function() {
return inputService.antiForgeryTokens();
};
kendo$1.cycleForm = function(form) {
return focusUtilsService.cycleForm(form);
};
kendo$1.focusElement = function(element) {
return focusUtilsService.focusElement(element);
};
kendo$1.focusNextElement = function() {
return focusUtilsService.focusNextElement();
};
kendo$1.getWidgetFocusableElement = function(element) {
return focusUtilsService.getWidgetFocusableElement(element);
};
kendo$1._activeElement = function() {
return focusUtilsService.activeElement();
};
focusUtilsService.registerFocusableSelector();
kendo$1.matchesMedia = function(mediaQuery) {
return supportService.matchesMedia(mediaQuery);
};
kendo$1._bootstrapToMedia = function(bootstrapMedia) {
return supportService.bootstrapToMedia(bootstrapMedia);
};
kendo$1.fileGroupMap = fileUtilsService.fileGroupMap;
kendo$1.getFileGroup = function(extension, withPrefix) {
return fileUtilsService.getFileGroup(extension, withPrefix);
};
kendo$1.getFileSizeMessage = function(size) {
return fileUtilsService.getFileSizeMessage(size);
};
kendo$1.saveAs = function(options) {
return fileUtilsService.saveAs(options);
};
kendo$1.selectorFromClasses = function(classes) {
return selectorService.selectorFromClasses(classes);
};
kendo$1.cssProperties = {
get positionModeValues() {
return cssPropertiesService.positionModeValues;
},
get roundedValues() {
return cssPropertiesService.roundedValues;
},
get sizeValues() {
return cssPropertiesService.sizeValues;
},
get shapeValues() {
return cssPropertiesService.shapeValues;
},
get fillModeValues() {
return cssPropertiesService.fillModeValues;
},
get themeColorValues() {
return cssPropertiesService.themeColorValues;
},
get resizeValues() {
return cssPropertiesService.resizeValues;
},
get overflowValues() {
return cssPropertiesService.overflowValues;
},
get layoutFlowValues() {
return cssPropertiesService.layoutFlowValues;
},
get defaultValues() {
return cssPropertiesService.defaultValues;
},
set defaultValues(value) {
cssPropertiesService.defaultValues = value;
},
get propertyDictionary() {
return cssPropertiesService.propertyDictionary;
},
set propertyDictionary(value) {
cssPropertiesService.propertyDictionary = value;
},
registerValues: function(widget, args) {
return cssPropertiesService.registerValues(widget, args);
},
getValidClass: function(args) {
return cssPropertiesService.getValidClass(args);
},
registerPrefix: function(widget, prefix) {
return cssPropertiesService.registerPrefix(widget, prefix);
},
get propertyToCssClassMap() {
return cssPropertiesService.propertyToCssClassMap;
},
registerCssClass: function(propName, value, shorthand) {
return cssPropertiesService.registerCssClass(propName, value, shorthand);
},
registerCssClasses: function(propName, arr) {
return cssPropertiesService.registerCssClasses(propName, arr);
},
getValidCssClass: function(prefix, propName, value) {
return cssPropertiesService.getValidCssClass(prefix, propName, value);
}
};
kendo$1.registerCssClass = function(propName, value, shorthand) {
return cssPropertiesService.registerCssClass(propName, value, shorthand);
};
kendo$1.registerCssClasses = function(propName, arr) {
return cssPropertiesService.registerCssClasses(propName, arr);
};
kendo$1.getValidCssClass = function(prefix, propName, value) {
return cssPropertiesService.getValidCssClass(prefix, propName, value);
};
kendo$1.propertyToCssClassMap = cssPropertiesService.propertyToCssClassMap;
kendo$1.proxyModelSetters = function proxyModelSetters(data) {
const observable = {};
Object.keys(data || {}).forEach(function(property) {
Object.defineProperty(observable, property, {
get: function() {
return data[property];
},
set: function(value) {
data[property] = value;
data.dirty = true;
}
});
});
return observable;
};
kendo$1.getSeriesColors = function() {
return colorService.getSeriesColors();
};
kendo$1.defaults = defaultsService.getDefaults();
kendo$1.setDefaults = function(key, value) {
defaultsService.setDefaults(key, value);
};
kendo$1.setIcons = function(dictionary) {
iconService.setIcons(dictionary);
};
kendo$1.debugTemplates = window.DEBUG_KENDO_TEMPLATES;
kendo$1.setDefaults("breakpoints", defaultBreakpoints);
kendo$1.class2type = typeUtilsService.getClass2Type();
kendo$1.type = function(obj) {
return typeUtilsService.type(obj);
};
//#endregion
Object.defineProperty(exports, "Widget", {
enumerable: true,
get: function() {
return Widget;
}
});
Object.defineProperty(exports, "cssPropertiesService", {
enumerable: true,
get: function() {
return cssPropertiesService;
}
});
Object.defineProperty(exports, "dateParserService", {
enumerable: true,
get: function() {
return dateParserService;
}
});
Object.defineProperty(exports, "dateUtilsService", {
enumerable: true,
get: function() {
return dateUtilsService;
}
});
Object.defineProperty(exports, "domUtilsService", {
enumerable: true,
get: function() {
return domUtilsService;
}
});
Object.defineProperty(exports, "fileUtilsService", {
enumerable: true,
get: function() {
return fileUtilsService;
}
});
Object.defineProperty(exports, "formatterService", {
enumerable: true,
get: function() {
return formatterService;
}
});
Object.defineProperty(exports, "fromESClass", {
enumerable: true,
get: function() {
return fromESClass;
}
});
Object.defineProperty(exports, "htmlService", {
enumerable: true,
get: function() {
return htmlService;
}
});
Object.defineProperty(exports, "iconService", {
enumerable: true,
get: function() {
return iconService;
}
});
Object.defineProperty(exports, "kendo", {
enumerable: true,
get: function() {
return kendo$1;
}
});
Object.defineProperty(exports, "utilsService", {
enumerable: true,
get: function() {
return utilsService;
}
});
Object.defineProperty(exports, "widgetRegistryService", {
enumerable: true,
get: function() {
return widgetRegistryService;
}
});