@progress/kendo-dateinputs-common 0.1.0 → 0.2.0-dev.202301061353

package/dist/npm/common/key.d.ts

@@ -0,0 +1,16 @@
+export declare const Key: {
+    DELETE: string;
+    BACKSPACE: string;
+    TAB: string;
+    ENTER: string;
+    ESCAPE: string;
+    ARROW_LEFT: string;
+    ARROW_UP: string;
+    ARROW_RIGHT: string;
+    ARROW_DOWN: string;
+    SPACE: string;
+    END: string;
+    HOME: string;
+    PAGE_UP: string;
+    PAGE_DOWN: string;
+};

package/dist/npm/common/key.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Key = {
+    DELETE: "Delete",
+    BACKSPACE: "Backspace",
+    TAB: "Tab",
+    ENTER: "Enter",
+    ESCAPE: "Escape",
+    ARROW_LEFT: "ArrowLeft",
+    ARROW_UP: "ArrowUp",
+    ARROW_RIGHT: "ArrowRight",
+    ARROW_DOWN: "ArrowDown",
+    SPACE: " ",
+    END: "End",
+    HOME: "Home",
+    PAGE_UP: "PageUp",
+    PAGE_DOWN: "PageDown"
+};

package/dist/npm/common/keycode.d.ts

@@ -0,0 +1,16 @@
+export declare const KeyCode: {
+    BACKSPACE: number;
+    DELETE: number;
+    TAB: number;
+    ENTER: number;
+    ESCAPE: number;
+    ARROW_LEFT: number;
+    ARROW_UP: number;
+    ARROW_RIGHT: number;
+    ARROW_DOWN: number;
+    SPACE: number;
+    END: number;
+    HOME: number;
+    PAGE_UP: number;
+    PAGE_DOWN: number;
+};

package/dist/npm/common/keycode.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyCode = {
+    BACKSPACE: 8,
+    DELETE: 46,
+    TAB: 9,
+    ENTER: 13,
+    ESCAPE: 27,
+    ARROW_LEFT: 37,
+    ARROW_UP: 38,
+    ARROW_RIGHT: 39,
+    ARROW_DOWN: 40,
+    SPACE: 32,
+    END: 35,
+    HOME: 36,
+    PAGE_UP: 33,
+    PAGE_DOWN: 34
+};

package/dist/npm/common/mask.d.ts

@@ -0,0 +1,4 @@
+export declare class Mask {
+    symbols: string;
+    partMap: any[];
+}

package/dist/npm/common/mask.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Mask = /** @class */ (function () {
+    function Mask() {
+        this.symbols = '';
+        this.partMap = [];
+    }
+    return Mask;
+}());
+exports.Mask = Mask;

package/dist/npm/common/observable.d.ts

@@ -0,0 +1,9 @@
+export declare class Observable {
+    options: any;
+    constructor(options: any);
+    destroy(): void;
+    /**
+     * @hidden
+     */
+    trigger(eventName: any, args?: {}): boolean;
+}

package/dist/npm/common/observable.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("./utils");
+var defaultOptions = {
+    events: {}
+};
+var Observable = /** @class */ (function () {
+    function Observable(options) {
+        this.options = utils_1.extend({}, defaultOptions, options);
+    }
+    Observable.prototype.destroy = function () {
+    };
+    /**
+     * @hidden
+     */
+    Observable.prototype.trigger = function (eventName, args) {
+        if (args === void 0) { args = {}; }
+        var eventData = {
+            defaultPrevented: false,
+            preventDefault: function () {
+                eventData.defaultPrevented = true;
+            }
+        };
+        if (utils_1.isFunction(this.options.events[eventName])) {
+            this.options.events[eventName](utils_1.extend(eventData, args, {
+                sender: this
+            }));
+            return eventData.defaultPrevented;
+        }
+        return false;
+    };
+    return Observable;
+}());
+exports.Observable = Observable;

package/dist/npm/common/utils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @hidden
+ */
+export declare const isPresent: (value: any) => boolean;
+/**
+ * @hidden
+ */
+export declare const isDocumentAvailable: () => boolean;
+/**
+ * @hidden
+ */
+export declare const isNumber: (value: any) => boolean;
+/**
+ * @hidden
+ */
+export declare const parseToInt: (value: any) => number;
+/**
+ * @hidden
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+/**
+ * @hidden
+ */
+export declare const extend: (...args: any[]) => any;
+/**
+ * @hidden
+ */
+export declare const deepExtend: (target: any, ...sources: any[]) => any;
+/**
+ * @hidden
+ */
+export declare const noop: () => any;
+/**
+ * @hidden
+ */
+export declare const isFunction: (fn: any) => boolean;
+/**
+ * @hidden
+ */
+export declare const cropTwoDigitYear: (date: Date) => number;
+/**
+ * @hidden
+ */
+export declare const setYears: (date: Date, value: number) => Date;
+/**
+ * @hidden
+ */
+export declare const millisecondDigitsInFormat: (format: string) => number;
+/**
+ * @hidden
+ */
+export declare const millisecondStepFor: (digits: number) => number;
+/**
+ * @hidden
+ */
+export declare const areDatePartsEqualTo: (date: any, year: any, month: any, day: any, hour: any, minutes: any, seconds: any, milliseconds: any) => boolean;
+/**
+ * @hidden
+ */
+export declare const isDate: (value: any) => boolean;

package/dist/npm/common/utils.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var kendo_date_math_1 = require("@progress/kendo-date-math");
+var isObject = function (value) { return value && typeof (value) === "object" && !Array.isArray(value); };
+var isHtmlElement = function (element) { return element instanceof HTMLElement; };
+var dateSetter = function (method) { return function (date, value) {
+    var clone = kendo_date_math_1.cloneDate(date);
+    clone[method](value);
+    return clone;
+}; };
+/**
+ * @hidden
+ */
+exports.isPresent = function (value) { return value !== undefined && value !== null; };
+/**
+ * @hidden
+ */
+exports.isDocumentAvailable = function () { return !!document; };
+/**
+ * @hidden
+ */
+exports.isNumber = function (value) { return exports.isPresent(value) && typeof (value) === "number" && !Number.isNaN(value); };
+/**
+ * @hidden
+ */
+exports.parseToInt = function (value) { return parseInt(value, 10); };
+/**
+ * @hidden
+ */
+exports.clamp = function (value, min, max) { return Math.min(max, Math.max(min, value)); };
+/**
+ * @hidden
+ */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+exports.extend = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return Object.assign.apply(Object, args);
+};
+/**
+ * @hidden
+ */
+exports.deepExtend = function (target) {
+    var _a, _b;
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    if (!sources.length) {
+        return target;
+    }
+    var source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (var key in source) {
+            if (isHtmlElement(source[key])) {
+                target[key] = source[key];
+            }
+            else if (isObject(source[key])) {
+                if (!target[key]) {
+                    exports.extend(target, (_a = {}, _a[key] = {}, _a));
+                }
+                exports.deepExtend(target[key], source[key]);
+            }
+            else {
+                exports.extend(target, (_b = {}, _b[key] = source[key], _b));
+            }
+        }
+    }
+    return exports.deepExtend.apply(void 0, [target].concat(sources));
+};
+/**
+ * @hidden
+ */
+exports.noop = function () { };
+/**
+ * @hidden
+ */
+exports.isFunction = function (fn) { return typeof (fn) === "function"; };
+/**
+ * @hidden
+ */
+exports.cropTwoDigitYear = function (date) {
+    if (!exports.isPresent(date) || isNaN(date.getTime())) {
+        return 0;
+    }
+    return Number(date
+        .getFullYear()
+        .toString()
+        .slice(-2));
+};
+/**
+ * @hidden
+ */
+exports.setYears = dateSetter('setFullYear');
+/**
+ * @hidden
+ */
+exports.millisecondDigitsInFormat = function (format) {
+    var result = format && format.match(/S+(\1)/);
+    return result ? result[0].length : 0;
+};
+/**
+ * @hidden
+ */
+exports.millisecondStepFor = function (digits) {
+    return Math.pow(10, 3 - digits);
+};
+/**
+ * @hidden
+ */
+exports.areDatePartsEqualTo = function (date, year, month, day, hour, minutes, seconds, milliseconds) {
+    if (date &&
+        date.getFullYear() === year &&
+        date.getMonth() === month &&
+        date.getDate() === day &&
+        date.getHours() === hour &&
+        date.getMinutes() === minutes &&
+        date.getSeconds() === seconds &&
+        date.getMilliseconds() === milliseconds) {
+        return true;
+    }
+    return false;
+};
+/**
+ * @hidden
+ */
+exports.isDate = function (value) { return exports.isPresent(value) && value.getTime && exports.isNumber(value.getTime()); };

package/dist/npm/dateinput/dateinput.d.ts

@@ -0,0 +1,204 @@
+import { DateObject } from '../common/dateobject';
+import { Observable } from '../common/observable';
+export declare class DateInput extends Observable {
+    readonly value: Date | null;
+    private dateObject;
+    private currentText;
+    private currentFormat;
+    private element;
+    private resetSegmentValue;
+    private isActive;
+    private interactionMode;
+    private previousElementValue;
+    private keyDownEvent;
+    private isPasteInProgress;
+    private mouseDownStarted;
+    private focusedPriorToMouseDown;
+    private intl;
+    private formatPlaceholder;
+    private localeId;
+    constructor(element: any, options: any);
+    init(element: any, options: any): void;
+    destroy(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    setOptions(options: any, refresh?: boolean): void;
+    /**
+     * @hidden
+     */
+    resetLocale(): void;
+    /**
+     * @hidden
+     */
+    isInCaretMode(): boolean;
+    focus(): void;
+    /**
+     * @hidden
+     */
+    onElementDragStart(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementDrop(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementMouseDown(): void;
+    /**
+     * @hidden
+     */
+    onElementMouseUp(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementClick(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementInput(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementFocus(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementBlur(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementChange(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementKeyDown(e: any): void;
+    /**
+     * @hidden
+     */
+    onElementPaste(): void;
+    /**
+     * @hidden
+     */
+    onElementMouseWheel(e: any): void;
+    updateOnPaste(e: any): void;
+    readonly elementValue: string;
+    readonly inputFormat: string;
+    private readonly displayFormat;
+    readonly selection: {
+        start: number;
+        end: number;
+    };
+    setSelection(selection: any): void;
+    /**
+     * @hidden
+     */
+    selectionBySymbol(symbol: any): any;
+    /**
+     * @hidden
+     */
+    selectionByIndex(index: any): any;
+    switchDateSegment(offset: any): void;
+    modifyDateSegmentValue(offset: any, symbol?: string, event?: {}): void;
+    /**
+     * @hidden
+     */
+    tryTriggerValueChange(args?: {
+        oldValue: any;
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerValueChange(args?: {
+        oldValue: any;
+        event: {};
+    }): boolean;
+    /**
+     * @hidden
+     */
+    triggerInput(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerInputEnd(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerFocus(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerFocusEnd(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerBlur(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerBlurEnd(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerChange(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerKeyDown(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    triggerMouseWheel(args?: {
+        event: {};
+    }): any;
+    /**
+     * @hidden
+     */
+    forceUpdate(): void;
+    /**
+     * @hidden
+     */
+    setTextAndFormat(): void;
+    /**
+     * @hidden
+     */
+    setElementValue(value: any): void;
+    /**
+     * @hidden
+     */
+    getStepFromSymbol(symbol: any): number;
+    setPreviousInputEventState(keyDownEvent: any): void;
+    writeValue(value: Date): void;
+    verifyValue(value: Date): void;
+    refreshElementValue(): void;
+    /**
+     * @hidden
+     */
+    caret(start?: number, end?: number): number[];
+    selectNearestSegment(index: number): void;
+    selectDateSegment(symbol: string): void;
+    /**
+     * @hidden
+     */
+    getDateObject(value: Date): DateObject;
+    /**
+     * @hidden
+     */
+    createDateObject(options?: {}): DateObject;
+}