@progress/kendo-vue-inputs 3.5.0 → 3.5.1-dev.202208100944

package/dist/esm/maskedtextbox/MaskedTextBoxProps.d.ts

@@ -0,0 +1,219 @@
+import { FormComponentProps } from '@progress/kendo-vue-common';
+/**
+ * The arguments for a MaskedTextBox event.
+ */
+export interface MaskedTextBoxEvent {
+    /**
+     * A native DOM event.
+     */
+    event: Event;
+    /**
+     * An event target.
+     */
+    target: any;
+}
+/**
+ * The arguments for the `change` event of the MaskedTextBox.
+ */
+export interface MaskedTextBoxChangeEvent extends MaskedTextBoxEvent {
+    /**
+     * Specifies the start of the selection which will be set to the MaskedTextBox when it is updated.
+     */
+    selectionStart: number;
+    /**
+     * Specifies the end of the selection which will be set to the MaskedTextBox when it is updated.
+     */
+    selectionEnd: number;
+    /**
+     * The current value of the component.
+     */
+    value: any;
+}
+/**
+ * Represents the props of the [Kendo UI for Vue MaskedTextBox component]({% slug overview_maskedtextbox %}).
+ */
+export interface MaskedTextBoxProps extends FormComponentProps {
+    /**
+     * Specifies the value of the MaskedTextBox.
+     */
+    value?: string;
+    /**
+     * Specifies the initial value. Leaves the subsequent updates uncontrolled.
+     */
+    defaultValue?: string;
+    /**
+     * Specifies the input placeholder.
+     */
+    placeholder?: string;
+    /**
+     * Sets the title of the `input` element of the MaskedTextBox.
+     */
+    title?: string;
+    /**
+     * Represents the `dir` HTML attribute.
+     */
+    dir?: string;
+    /**
+     * Configures the `size` of the MaskedTextBox.
+     *
+     * The available options are:
+     * - small
+     * - medium
+     * - large
+     * - null—Does not set a size `class`.
+     *
+     * @default `medium`
+     */
+    size?: null | 'small' | 'medium' | 'large' | string;
+    /**
+     * Configures the `roundness` of the MaskedTextBox.
+     *
+     * The available options are:
+     * - small
+     * - medium
+     * - large
+     * - full
+     * - null—Does not set a rounded `class`.
+     *
+     * @default `medium`
+     */
+    rounded?: null | 'small' | 'medium' | 'large' | 'full' | string;
+    /**
+     * Configures the `fillMode` of the MaskedTextBox.
+     *
+     * The available options are:
+     * - solid
+     * - outline
+     * - flat
+     * - null—Does not set a fillMode `class`.
+     *
+     * @default `solid`
+     */
+    fillMode?: null | 'solid' | 'flat' | 'outline' | string;
+    /**
+     * Sets the `tabIndex` property of the MaskedTextBox.
+     */
+    tabIndex?: number;
+    /**
+     * Specifies the `accessKey` of the MaskedTextBox.
+     */
+    accessKey?: string;
+    /**
+     * Specifies the width of the MaskedTextBox.
+     */
+    width?: number | string;
+    /**
+     * Determines whether the MaskedTextBox is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Renders a floating label for the MaskedTextBox.
+     */
+    label?: string;
+    /**
+     * Sets the `id` of the `input` DOM element.
+     */
+    id?: string;
+    /**
+     * Identifies the element(s) which will describe the component, similar to [HTML aria-describedby attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_aria-describedby_attribute).
+     * For example these elements could contain error or hint message.
+     */
+    ariaDescribedBy?: string;
+    /**
+     * Identifies the element(s) which will label the component.
+     */
+    ariaLabelledBy?: string;
+    /**
+     * Determines whether the MaskedTextBox is in its read-only state.
+     */
+    readonly?: boolean;
+    /**
+     * Represents a prompt character for the masked value. Defaults to `_`.
+     */
+    prompt?: string;
+    /**
+     * Indicates a character which represents an empty position in the raw value. Defaults to ` `.
+     */
+    promptPlaceholder?: string;
+    /**
+     * Indicates whether to include literals in the raw value. Defaults to `false`.
+     */
+    includeLiterals?: boolean;
+    /**
+     * Determines whether the built-in mask validator is enforced when a form is validated. Defaults to `true`.
+     */
+    maskValidation?: boolean;
+    /**
+     * Represents the current mask. If no mask is set, the component behaves as a standard `type="text"` input.
+     */
+    mask?: string;
+    /**
+     * Represents the RegExp-based mask validation array.
+     */
+    rules?: {
+        [key: string]: RegExp;
+    };
+    /**
+     * Represents the beginning and ending of the selected portion of the input content that will be applied the next time when the MaskedTextBox is rendered.
+     */
+    selection?: {
+        start: number;
+        end: number;
+    };
+    /**
+     * Determines the event handler that will be fired when the user edits the value.
+     */
+    onChange?: (event: MaskedTextBoxChangeEvent) => void;
+    /**
+     * Fires each time the user focuses the MaskedTextBox.
+     */
+    onFocus?: (event: MaskedTextBoxEvent) => void;
+    /**
+     * Fires each time the MaskedTextBox gets blurred.
+     */
+    onBlur?: (event: MaskedTextBoxEvent) => void;
+    /**
+     * v-model raw value
+     */
+    modelRawValue?: string;
+    /**
+     * v-model value
+     */
+    modelValue?: string;
+    /**
+     * The type of the input - 'text' by default
+     */
+    type?: string;
+    /**
+     * Defines a string prop that controls the input icon.
+     */
+    iconName?: String;
+    /**
+     * Defines if the inputPrefix will be shown. Accepts a slot name, a `render` function, or a Vue component.
+     */
+    inputPrefix?: Boolean | String | Object | Function;
+    /**
+     * Defines if the inputSuffix will be shown. Accepts a slot name, a `render` function, or a Vue component.
+     */
+    inputSuffix?: Boolean | String | Object | Function;
+    /**
+     * Defines a boolean prop that controls whether to show the validation icon. Defaults to 'false'.
+     */
+    showValidationIcon?: Boolean;
+    /**
+     * Defines a boolean prop that controls whether to show the loading icon. Defaults to 'false'.
+     */
+    showLoadingIcon?: Boolean;
+    /**
+     * Defines a boolean prop that controls whether to show the clear icon. Defaults to 'false'.
+     */
+    showClearButton?: Boolean;
+    /**
+     * Defines additional class to the inner input element.
+     */
+    inputClass?: String;
+    /**
+     * Defines additional class to the wrapper element.
+     */
+    wrapperClass?: String;
+}

package/dist/esm/maskedtextbox/MaskedTextBoxProps.js

@@ -0,0 +1,2 @@
+export {};
+// tslint:enable:max-line-length

package/dist/esm/maskedtextbox/masking.service.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @hidden
+ */
+export declare class MaskingService {
+    rules: {
+        [key: string]: RegExp;
+    };
+    prompt: string;
+    mask: string;
+    promptPlaceholder: string;
+    includeLiterals: boolean;
+    maskTokens: any[];
+    unmaskTokens: any[];
+    rawTokens: any[];
+    validationTokens: any[];
+    update({ mask, prompt, promptPlaceholder, rules, includeLiterals }: any): void;
+    validationValue(maskedValue?: string): string;
+    rawValue(maskedValue?: string): string;
+    /**
+     * @hidden
+     */
+    maskRaw(rawValue?: string): string;
+    maskInput(input: string, control: string, splitPoint: number): any;
+    maskInRange(pasted: string, oldValue: string, start: number, end: number): any;
+    private maskRemoved;
+    private adjustPosition;
+    private maskInserted;
+    protected get maskTokenCreator(): {
+        [key: string]: Function;
+    };
+    protected get unmaskTokenCreator(): {
+        [key: string]: Function;
+    };
+    protected get rawTokenCreator(): {
+        [key: string]: Function;
+    };
+    protected get validationTokenCreator(): {
+        [key: string]: Function;
+    };
+    private tokenize;
+}

package/dist/esm/maskedtextbox/masking.service.js

@@ -0,0 +1,206 @@
+import { greedy, sequence } from './parsing/combinators.js';
+import { literal, mask as maskParser, rawLiteral, rawMask, token, unliteral, unmask } from './parsing/parsers.js';
+/**
+ * @hidden
+ */
+var MaskingService = /** @class */ (function () {
+    function MaskingService() {
+        this.rules = {};
+        this.prompt = '_';
+        this.mask = '';
+        this.promptPlaceholder = ' ';
+        this.includeLiterals = false;
+        this.maskTokens = [];
+        this.unmaskTokens = [];
+        this.rawTokens = [];
+        this.validationTokens = [];
+    }
+    MaskingService.prototype.update = function (_a) {
+        var _b = _a.mask, mask = _b === void 0 ? '' : _b, _c = _a.prompt, prompt = _c === void 0 ? '' : _c, _d = _a.promptPlaceholder, promptPlaceholder = _d === void 0 ? ' ' : _d, _e = _a.rules, rules = _e === void 0 ? {} : _e, _f = _a.includeLiterals, includeLiterals = _f === void 0 ? false : _f;
+        this.mask = mask;
+        this.prompt = prompt;
+        this.promptPlaceholder = promptPlaceholder;
+        this.rules = rules;
+        this.includeLiterals = includeLiterals;
+        this.tokenize();
+    };
+    MaskingService.prototype.validationValue = function (maskedValue) {
+        if (maskedValue === void 0) { maskedValue = ''; }
+        var value = maskedValue;
+        sequence(this.validationTokens)
+            .run(maskedValue)
+            .fold(function (unmasked) {
+            value = unmasked.join('');
+        });
+        return value;
+    };
+    MaskingService.prototype.rawValue = function (maskedValue) {
+        if (maskedValue === void 0) { maskedValue = ''; }
+        var value = maskedValue;
+        if (!this.rawTokens.length) {
+            return value;
+        }
+        sequence(this.rawTokens)
+            .run(maskedValue)
+            .fold(function (unmasked) {
+            value = unmasked.join('');
+        });
+        return value;
+    };
+    /**
+     * @hidden
+     */
+    MaskingService.prototype.maskRaw = function (rawValue) {
+        if (rawValue === void 0) { rawValue = ''; }
+        var value = rawValue;
+        if (!this.maskTokens.length) {
+            return value;
+        }
+        sequence(this.maskTokens)
+            .run(rawValue)
+            .fold(function (masked) {
+            value = masked.join('');
+        });
+        return value;
+    };
+    MaskingService.prototype.maskInput = function (input, control, splitPoint) {
+        if (input.length < control.length) {
+            return this.maskRemoved(input, control, splitPoint);
+        }
+        return this.maskInserted(input, control, splitPoint);
+    };
+    MaskingService.prototype.maskInRange = function (pasted, oldValue, start, end) {
+        var value = '';
+        var selection = end;
+        var beforeChange = oldValue.split('').slice(0, start);
+        var afterChange = oldValue.split('').slice(end);
+        sequence(this.maskTokens.slice(start, end))
+            .run(pasted)
+            .fold(function (masked) {
+            value = beforeChange
+                .concat(masked)
+                .concat(afterChange)
+                .join('');
+        });
+        return {
+            selection: selection,
+            value: value
+        };
+    };
+    MaskingService.prototype.maskRemoved = function (input, control, splitPoint) {
+        var _this = this;
+        var value = '';
+        var selection = splitPoint;
+        var unchanged = input.split('').slice(splitPoint);
+        var changed = input.split('').slice(0, splitPoint).join('');
+        var take = this.maskTokens.length - (input.length - splitPoint);
+        sequence(this.maskTokens.slice(0, take))
+            .run(changed, control)
+            .fold(function (masked) {
+            selection = _this.adjustPosition(masked, selection);
+            value = masked.concat(unchanged).join('');
+        });
+        return {
+            selection: selection,
+            value: value
+        };
+    };
+    MaskingService.prototype.adjustPosition = function (input, selection) {
+        var caretChar = input[selection];
+        var isLiteral = this.maskTokens[selection].isLiteral(caretChar);
+        if (!isLiteral && caretChar !== this.prompt) {
+            return selection + 1;
+        }
+        return selection;
+    };
+    MaskingService.prototype.maskInserted = function (input, control, splitPoint) {
+        var _this = this;
+        var value = '';
+        var selection = splitPoint;
+        var changed = input.slice(0, splitPoint);
+        sequence(this.unmaskTokens)
+            .run(changed, control)
+            .chain(function (unmasked) {
+            selection = unmasked.join('').length;
+            var unchanged = control.slice(selection);
+            return sequence(_this.maskTokens)
+                .run(unmasked.join('') + unchanged, control);
+        })
+            .fold(function (masked) {
+            value = masked.join('');
+        });
+        return {
+            selection: selection,
+            value: value
+        };
+    };
+    Object.defineProperty(MaskingService.prototype, "maskTokenCreator", {
+        get: function () {
+            var _a = this, prompt = _a.prompt, promptPlaceholder = _a.promptPlaceholder;
+            return {
+                literal: function (rule) { return literal(rule); },
+                mask: function (rule) { return maskParser({ prompt: prompt, promptPlaceholder: promptPlaceholder })(rule); }
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MaskingService.prototype, "unmaskTokenCreator", {
+        get: function () {
+            var _this = this;
+            return {
+                literal: function (rule) { return unliteral(rule); },
+                mask: function (rule) { return unmask(_this.prompt)(rule); }
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MaskingService.prototype, "rawTokenCreator", {
+        get: function () {
+            var _a = this, prompt = _a.prompt, promptPlaceholder = _a.promptPlaceholder, includeLiterals = _a.includeLiterals;
+            return {
+                literal: function (_) { return rawLiteral(includeLiterals); },
+                mask: function (_) { return rawMask({ prompt: prompt, promptPlaceholder: promptPlaceholder }); }
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MaskingService.prototype, "validationTokenCreator", {
+        get: function () {
+            var prompt = this.prompt;
+            return {
+                literal: function (_) { return rawLiteral(false); },
+                mask: function (_) { return rawMask({ prompt: prompt, promptPlaceholder: '' }); }
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MaskingService.prototype.tokenize = function () {
+        var _this = this;
+        greedy(token(this.rules, this.maskTokenCreator))
+            .run(this.mask)
+            .fold(function (tokens, _) {
+            _this.maskTokens = tokens;
+        });
+        greedy(token(this.rules, this.unmaskTokenCreator))
+            .run(this.mask)
+            .fold(function (tokens, _) {
+            _this.unmaskTokens = tokens;
+        });
+        greedy(token(this.rules, this.rawTokenCreator))
+            .run(this.mask)
+            .fold(function (tokens, _) {
+            _this.rawTokens = tokens;
+        });
+        greedy(token(this.rules, this.validationTokenCreator))
+            .run(this.mask)
+            .fold(function (tokens, _) {
+            _this.validationTokens = tokens;
+        });
+    };
+    return MaskingService;
+}());
+export { MaskingService };

package/dist/esm/maskedtextbox/parsing/combinators.d.ts

@@ -0,0 +1,9 @@
+import { Parser } from './parsers';
+/**
+ * @hidden
+ */
+export declare const sequence: (list: any) => any;
+/**
+ * @hidden
+ */
+export declare const greedy: (parser: any) => Parser;

package/dist/esm/maskedtextbox/parsing/combinators.js

@@ -0,0 +1,24 @@
+import { Parser } from './parsers.js';
+import { Result } from './result.js';
+/**
+ * @hidden
+ */
+var always = function (value) { return new Parser(function (stream) { return new Result(value, stream); }); };
+/**
+ * @hidden
+ */
+var append = function (p1, p2) { return p1.chain(function (vs) { return p2.map(function (v) { return vs.concat([v]); }); }); };
+/**
+ * @hidden
+ */
+export var sequence = function (list) { return list.reduce(function (acc, parser) { return append(acc, parser); }, always([])); };
+/**
+ * @hidden
+ */
+export var greedy = function (parser) { return new Parser(function (stream) {
+    var result = new Result([], stream);
+    while (!stream.eof()) {
+        result = result.concat(parser.run(stream));
+    }
+    return result;
+}); };

package/dist/esm/maskedtextbox/parsing/parsers.d.ts

@@ -0,0 +1,47 @@
+import { Result } from './result';
+import { Stream } from './stream';
+/**
+ * @hidden
+ */
+export declare class Parser {
+    private parse;
+    constructor(parse: Function);
+    run(input: Stream | string, control?: string): Result;
+    map(f: Function): Parser;
+    chain(f: Function): Parser;
+    isLiteral(c: string): boolean;
+}
+/**
+ * @hidden
+ */
+export declare const mask: ({ prompt, promptPlaceholder }: {
+    prompt: any;
+    promptPlaceholder: any;
+}) => (rule: any) => Parser;
+/**
+ * @hidden
+ */
+export declare const literal: (_token: any) => Parser;
+/**
+ * @hidden
+ */
+export declare const unmask: (prompt: any) => (rule: any) => Parser;
+/**
+ * @hidden
+ */
+export declare const unliteral: (_token: any) => Parser;
+/**
+ * @hidden
+ */
+export declare const token: (rules: any, creator: any) => Parser;
+/**
+ * @hidden
+ */
+export declare const rawMask: ({ prompt, promptPlaceholder }: {
+    prompt: any;
+    promptPlaceholder: any;
+}) => Parser;
+/**
+ * @hidden
+ */
+export declare const rawLiteral: (includeLiterals: any) => Parser;

package/dist/esm/maskedtextbox/parsing/parsers.js

@@ -0,0 +1,154 @@
+import { Result, ResultType } from './result.js';
+import { Stream } from './stream.js';
+var toArray = function (value) { return (value || '').split(''); };
+var ESCAPE_CHARACTER = '\\';
+/**
+ * @hidden
+ */
+var Parser = /** @class */ (function () {
+    function Parser(parse) {
+        this.parse = parse;
+    }
+    Parser.prototype.run = function (input, control) {
+        if (control === void 0) { control = ''; }
+        if (input instanceof Stream) {
+            return this.parse(input);
+        }
+        else {
+            return this.parse(new Stream(toArray(input), toArray(control)));
+        }
+    };
+    // map :: Functor f => f a ~> (a -> b) -> f b
+    Parser.prototype.map = function (f) {
+        var _this = this;
+        return new Parser(function (stream) { return _this.parse(stream).map(f); });
+    };
+    // chain :: Chain m => m a ~> (a -> m b) -> m b
+    Parser.prototype.chain = function (f) {
+        var _this = this;
+        return new Parser(function (stream) { return _this.parse(stream).chain(function (v, s) { return f(v).run(s); }); });
+    };
+    Parser.prototype.isLiteral = function (c) {
+        return this.run(c).type === ResultType.Literal;
+    };
+    return Parser;
+}());
+export { Parser };
+/**
+ * @hidden
+ */
+export var mask = function (_a) {
+    var prompt = _a.prompt, promptPlaceholder = _a.promptPlaceholder;
+    return function (rule) { return new Parser(function (stream) {
+        while (!stream.eof()) {
+            var _a = stream.peek(), char = _a.char, control = _a.control;
+            if (char === control && control === prompt) {
+                stream.eat();
+                return new Result(prompt, stream, ResultType.Mask);
+            }
+            if (rule.test(char)) {
+                stream.eat();
+                return new Result(char, stream, ResultType.Mask);
+            }
+            if (char === promptPlaceholder) {
+                stream.eat();
+                return new Result(prompt, stream, ResultType.Mask);
+            }
+            stream.eat_input();
+        }
+        stream.eat();
+        return new Result(prompt, stream, ResultType.Mask);
+    }); };
+};
+/**
+ * @hidden
+ */
+export var literal = function (_token) { return new Parser(function (stream) {
+    //    let {char, control} = stream.peek();
+    var char = stream.peek().char;
+    if (char === _token) {
+        stream.eat();
+        return new Result(_token, stream, ResultType.Literal);
+    }
+    //    if (control === _token) {
+    //        while (!stream.eof() && char !== _token) {
+    //            stream.eat_input();
+    //            char = stream.peek().char;
+    //        }
+    //    }
+    //
+    //    if (control !== undefined) {
+    //        stream.eat();
+    //    }
+    return new Result(_token, stream, ResultType.Literal);
+}); };
+/**
+ * @hidden
+ */
+export var unmask = function (prompt) { return function (rule) { return new Parser(function (stream) {
+    while (!stream.eof()) {
+        var _a = stream.peek(), char = _a.char, control = _a.control;
+        if (char === prompt && control === prompt) {
+            stream.eat();
+            return new Result(char, stream);
+        }
+        if (rule.test(char)) {
+            stream.eat();
+            return new Result(char, stream);
+        }
+        stream.eat_input();
+    }
+    stream.eat();
+    return new Result('', stream);
+}); }; };
+/**
+ * @hidden
+ */
+export var unliteral = function (_token) { return new Parser(function (stream) {
+    if (stream.eof()) {
+        return new Result('', stream);
+    }
+    var char = stream.peek().char;
+    if (char === _token) {
+        stream.eat();
+    }
+    return new Result(_token, stream);
+}); };
+/**
+ * @hidden
+ */
+export var token = function (rules, creator) { return new Parser(function (stream) {
+    var char = stream.next().char;
+    var rule = rules[char];
+    if (char === ESCAPE_CHARACTER) {
+        char = stream.next().char;
+        return new Result(creator.literal(char), stream);
+    }
+    if (!rule) {
+        return new Result(creator.literal(char), stream);
+    }
+    return new Result(creator.mask(rule), stream);
+}); };
+/**
+ * @hidden
+ */
+export var rawMask = function (_a) {
+    var prompt = _a.prompt, promptPlaceholder = _a.promptPlaceholder;
+    return new Parser(function (stream) {
+        var char = stream.next().char;
+        if (char === prompt) {
+            return new Result(promptPlaceholder, stream);
+        }
+        return new Result(char, stream);
+    });
+};
+/**
+ * @hidden
+ */
+export var rawLiteral = function (includeLiterals) { return new Parser(function (stream) {
+    var char = stream.next().char;
+    if (includeLiterals) {
+        return new Result(char, stream);
+    }
+    return new Result('', stream);
+}); };