@syncfusion/ej2-base 24.2.7 → 25.1.35-579988

package/dist/ts/intl/parser-base.ts

@@ -0,0 +1,394 @@
+/**
+ * Parser
+ */
+
+const defaultNumberingSystem: Object = {
+    'latn': {
+        '_digits': '0123456789',
+        '_type': 'numeric'
+    }
+};
+
+import { isUndefined, getValue, isBlazor } from '../util';
+const defaultNumberSymbols: Object = {
+    'decimal': '.',
+    'group': ',',
+    'percentSign': '%',
+    'plusSign': '+',
+    'minusSign': '-',
+    'infinity': '∞',
+    'nan': 'NaN',
+    'exponential': 'E'
+};
+const latnNumberSystem: number[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+/**
+ * Interface for numeric Options
+ */
+export interface NumericOptions {
+    numericPair?: Object;
+    numericRegex?: string;
+    numberParseRegex?: RegExp;
+    symbolNumberSystem?: Object;
+    symbolMatch?: Object;
+    numberSystem?: string;
+}
+/**
+ * Interface for numeric object
+ */
+export interface NumericObject {
+    obj?: Object;
+    nSystem?: string;
+}
+/**
+ * Interface for number mapper
+ */
+export interface NumberMapper {
+    mapper?: Object;
+    timeSeparator?: string;
+    numberSymbols?: Object;
+    numberSystem?: string;
+}
+/**
+ * Interface for parser base
+ *
+ * @private
+ */
+export class ParserBase {
+    public static nPair: string = 'numericPair';
+    public static nRegex: string = 'numericRegex';
+    public static numberingSystems: Object = defaultNumberingSystem;
+    /**
+     * Returns the cldr object for the culture specifies
+     *
+     * @param {Object} obj - Specifies the object from which culture object to be acquired.
+     * @param {string} cName - Specifies the culture name.
+     * @returns {Object} ?
+     */
+    public static getMainObject(obj: Object, cName: string): Object {
+        const value: string = isBlazor() ? cName : 'main.' + cName;
+        return getValue(value, obj);
+    }
+    /**
+     * Returns the numbering system object from given cldr data.
+     *
+     * @param {Object} obj - Specifies the object from which number system is acquired.
+     * @returns {Object} ?
+     */
+    public static getNumberingSystem(obj: Object): Object {
+        return getValue('supplemental.numberingSystems', obj) || this.numberingSystems;
+    }
+    /**
+     * Returns the reverse of given object keys or keys specified.
+     *
+     * @param {Object} prop - Specifies the object to be reversed.
+     * @param {number[]} keys - Optional parameter specifies the custom keyList for reversal.
+     * @returns {Object} ?
+     */
+    public static reverseObject(prop: Object, keys?: number[]): Object {
+        const propKeys: string[] | number[] = keys || Object.keys(prop);
+        const res: Object = {};
+        for (const key of propKeys) {
+            // eslint-disable-next-line
+            if (!res.hasOwnProperty((<any>prop)[key])) {
+                // eslint-disable-next-line
+                (<any>res)[(<any>prop)[key]] = key;
+            }
+        }
+        return res;
+    }
+    /**
+     * Returns the symbol regex by skipping the escape sequence.
+     *
+     * @param {string[]} props - Specifies the array values to be skipped.
+     * @returns {RegExp} ?
+     */
+    public static getSymbolRegex(props: string[]): RegExp {
+        const regexStr: string = props.map((str: string): string => {
+            return str.replace(/([.*+?^=!:${}()|[\]/\\])/g, '\\$1');
+        }).join('|');
+        const regExp: RegExpConstructor = RegExp;
+        return new regExp(regexStr, 'g');
+    }
+    /**
+     *
+     * @param {Object} prop ?
+     * @returns {Object} ?
+     */
+    private static getSymbolMatch(prop: Object): Object {
+        const matchKeys: string[] = Object.keys(defaultNumberSymbols);
+        const ret: Object = {};
+        for (const key of matchKeys) {
+            // eslint-disable-next-line
+            (<any>ret)[(<any>prop)[key]] = (<any>defaultNumberSymbols)[key];
+        }
+        return ret;
+    }
+    /**
+     * Returns regex string for provided value
+     *
+     * @param {string} val ?
+     * @returns {string} ?
+     */
+    private static constructRegex(val: string): string {
+        const len: number = val.length;
+        let ret: string = '';
+        for (let i: number = 0; i < len; i++) {
+            if (i !== len - 1) {
+                ret += val[parseInt(i.toString(), 10)] + '|';
+            } else {
+                ret += val[parseInt(i.toString(), 10)];
+            }
+        }
+        return ret;
+    }
+    /**
+     * Returns the replaced value of matching regex and obj mapper.
+     *
+     * @param {string} value - Specifies the  values to be replaced.
+     * @param {RegExp} regex - Specifies the  regex to search.
+     * @param {Object} obj - Specifies the  object matcher to be replace value parts.
+     * @returns {string} ?
+     */
+    public static convertValueParts(value: string, regex: RegExp, obj: Object): string {
+        return value.replace(regex, (str: string): string => {
+            // eslint-disable-next-line
+            return (<any>obj)[str];
+        });
+    }
+    /**
+     * Returns default numbering system object for formatting from cldr data
+     *
+     * @param {Object} obj ?
+     * @returns {NumericObject} ?
+     */
+    public static getDefaultNumberingSystem(obj: Object): NumericObject {
+        const ret: NumericObject = {};
+        ret.obj = getValue('numbers', obj);
+        ret.nSystem = getValue('defaultNumberingSystem', ret.obj);
+        return ret;
+    }
+    /**
+     * Returns the replaced value of matching regex and obj mapper.
+     *
+     * @param {Object} curObj ?
+     * @param {Object} numberSystem ?
+     * @param {boolean} needSymbols ?
+     * @param {boolean} blazorMode ?
+     * @returns {Object} ?
+     */
+    public static getCurrentNumericOptions(curObj: Object, numberSystem: Object, needSymbols?: boolean, blazorMode?: boolean): Object {
+        const ret: NumericOptions = {};
+        const cur: NumericObject = this.getDefaultNumberingSystem(curObj);
+        if (!isUndefined(cur.nSystem) || blazorMode) {
+            const digits: string = blazorMode ? getValue('obj.mapperDigits', cur) : getValue(cur.nSystem + '._digits', numberSystem);
+            if (!isUndefined(digits)) {
+                ret.numericPair = this.reverseObject(digits, latnNumberSystem);
+                const regExp: RegExpConstructor = RegExp;
+                ret.numberParseRegex = new regExp(this.constructRegex(digits), 'g');
+                ret.numericRegex = '[' + digits[0] + '-' + digits[9] + ']';
+                if (needSymbols) {
+                    ret.numericRegex = digits[0] + '-' + digits[9];
+                    ret.symbolNumberSystem = getValue(blazorMode ? 'numberSymbols' : 'symbols-numberSystem-' + cur.nSystem, cur.obj);
+                    ret.symbolMatch = this.getSymbolMatch(ret.symbolNumberSystem);
+                    ret.numberSystem = cur.nSystem;
+                }
+            }
+        }
+        return ret;
+    }
+    /**
+     * Returns number mapper object for the provided cldr data
+     *
+     * @param {Object} curObj ?
+     * @param {Object} numberSystem ?
+     * @param {boolean} isNumber ?
+     * @returns {NumberMapper} ?
+     */
+    // eslint-disable-next-line
+    public static getNumberMapper(curObj: Object, numberSystem: Object, isNumber?: boolean): NumberMapper {
+        const ret: NumberMapper = { mapper: {} };
+        const cur: NumericObject = this.getDefaultNumberingSystem(curObj);
+        if (!isUndefined(cur.nSystem)) {
+            ret.numberSystem = cur.nSystem;
+            ret.numberSymbols = getValue('symbols-numberSystem-' + cur.nSystem, cur.obj);
+            ret.timeSeparator = getValue('timeSeparator', ret.numberSymbols);
+            const digits: string = getValue(cur.nSystem + '._digits', numberSystem);
+            if (!isUndefined(digits)) {
+                for (const i of latnNumberSystem) {
+                    // eslint-disable-next-line
+                    (<any>ret).mapper[i] = digits[i];
+                }
+            }
+        }
+        return ret;
+    }
+}
+/**
+ * @private
+ */
+const blazorCurrencyData: Object = {
+    'DJF': 'Fdj',
+    'ERN': 'Nfk',
+    'ETB': 'Br',
+    'NAD': '$',
+    'ZAR': 'R',
+    'XAF': 'FCFA',
+    'GHS': 'GH₵',
+    'XDR': 'XDR',
+    'AED': 'د.إ.',
+    'BHD': 'د.ب.',
+    'DZD': 'د.ج.',
+    'EGP': 'ج.م.',
+    'ILS': '₪',
+    'IQD': 'د.ع.',
+    'JOD': 'د.ا.',
+    'KMF': 'CF',
+    'KWD': 'د.ك.',
+    'LBP': 'ل.ل.',
+    'LYD': 'د.ل.',
+    'MAD': 'د.م.',
+    'MRU': 'أ.م.',
+    'OMR': 'ر.ع.',
+    'QAR': 'ر.ق.',
+    'SAR': 'ر.س.',
+    'SDG': 'ج.س.',
+    'SOS': 'S',
+    'SSP': '£',
+    'SYP': 'ل.س.',
+    'TND': 'د.ت.',
+    'YER': 'ر.ي.',
+    'CLP': '$',
+    'INR': '₹',
+    'TZS': 'TSh',
+    'EUR': '€',
+    'AZN': '₼',
+    'RUB': '₽',
+    'BYN': 'Br',
+    'ZMW': 'K',
+    'BGN': 'лв.',
+    'NGN': '₦',
+    'XOF': 'CFA',
+    'BDT': '৳',
+    'CNY': '¥',
+    'BAM': 'КМ',
+    'UGX': 'USh',
+    'USD': '$',
+    'CZK': 'Kč',
+    'GBP': '£',
+    'DKK': 'kr.',
+    'KES': 'Ksh',
+    'CHF': 'CHF',
+    'MVR': 'ރ.',
+    'BTN': 'Nu.',
+    'XCD': 'EC$',
+    'AUD': '$',
+    'BBD': '$',
+    'BIF': 'FBu',
+    'BMD': '$',
+    'BSD': '$',
+    'BWP': 'P',
+    'BZD': '$',
+    'CAD': '$',
+    'NZD': '$',
+    'FJD': '$',
+    'FKP': '£',
+    'GIP': '£',
+    'GMD': 'D',
+    'GYD': '$',
+    'HKD': '$',
+    'IDR': 'Rp',
+    'JMD': '$',
+    'KYD': '$',
+    'LRD': '$',
+    'MGA': 'Ar',
+    'MOP': 'MOP$',
+    'MUR': 'Rs',
+    'MWK': 'MK',
+    'MYR': 'RM',
+    'PGK': 'K',
+    'PHP': '₱',
+    'PKR': 'Rs',
+    'RWF': 'RF',
+    'SBD': '$',
+    'SCR': 'SR',
+    'SEK': 'kr',
+    'SGD': '$',
+    'SHP': '£',
+    'SLL': 'Le',
+    'ANG': 'NAf.',
+    'SZL': 'E',
+    'TOP': 'T$',
+    'TTD': '$',
+    'VUV': 'VT',
+    'WST': 'WS$',
+    'ARS': '$',
+    'BOB': 'Bs',
+    'BRL': 'R$',
+    'COP': '$',
+    'CRC': '₡',
+    'CUP': '$',
+    'DOP': '$',
+    'GTQ': 'Q',
+    'HNL': 'L',
+    'MXN': '$',
+    'NIO': 'C$',
+    'PAB': 'B/.',
+    'PEN': 'S/',
+    'PYG': '₲',
+    'UYU': '$',
+    'VES': 'Bs.S',
+    'IRR': 'ريال',
+    'GNF': 'FG',
+    'CDF': 'FC',
+    'HTG': 'G',
+    'XPF': 'FCFP',
+    'HRK': 'kn',
+    'HUF': 'Ft',
+    'AMD': '֏',
+    'ISK': 'kr',
+    'JPY': '¥',
+    'GEL': '₾',
+    'CVE': '​',
+    'KZT': '₸',
+    'KHR': '៛',
+    'KPW': '₩',
+    'KRW': '₩',
+    'KGS': 'сом',
+    'AOA': 'Kz',
+    'LAK': '₭',
+    'MZN': 'MTn',
+    'MKD': 'ден',
+    'MNT': '₮',
+    'BND': '$',
+    'MMK': 'K',
+    'NOK': 'kr',
+    'NPR': 'रु',
+    'AWG': 'Afl.',
+    'SRD': '$',
+    'PLN': 'zł',
+    'AFN': '؋',
+    'STN': 'Db',
+    'MDL': 'L',
+    'RON': 'lei',
+    'UAH': '₴',
+    'LKR': 'රු.',
+    'ALL': 'Lekë',
+    'RSD': 'дин.',
+    'TJS': 'смн',
+    'THB': '฿',
+    'TMT': 'm.',
+    'TRY': '₺',
+    'UZS': 'сўм',
+    'VND': '₫',
+    'TWD': 'NT$'
+};
+
+/**
+ *
+ * @param {string} currencyCode ?
+ * @returns {string} ?
+ */
+export function getBlazorCurrencySymbol(currencyCode: string): string {
+    return getValue(currencyCode || '', blazorCurrencyData);
+}
+

package/dist/ts/keyboard.ts

@@ -0,0 +1,238 @@
+import { Property, NotifyPropertyChanges, INotifyPropertyChanged, Event } from './notify-property-change';
+import { Base, EmitType } from './base';
+import { KeyboardEventsModel } from './keyboard-model';
+/**
+ * KeyboardEvents
+ */
+export interface KeyboardEventArgs extends KeyboardEvent {
+    /**
+     * action of the KeyboardEvent
+     */
+    action: string;
+}
+
+const keyCode: { [key: string]: number } = {
+    'backspace': 8,
+    'tab': 9,
+    'enter': 13,
+    'shift': 16,
+    'control': 17,
+    'alt': 18,
+    'pause': 19,
+    'capslock': 20,
+    'space': 32,
+    'escape': 27,
+    'pageup': 33,
+    'pagedown': 34,
+    'end': 35,
+    'home': 36,
+    'leftarrow': 37,
+    'uparrow': 38,
+    'rightarrow': 39,
+    'downarrow': 40,
+    'insert': 45,
+    'delete': 46,
+    'f1': 112,
+    'f2': 113,
+    'f3': 114,
+    'f4': 115,
+    'f5': 116,
+    'f6': 117,
+    'f7': 118,
+    'f8': 119,
+    'f9': 120,
+    'f10': 121,
+    'f11': 122,
+    'f12': 123,
+    'semicolon': 186,
+    'plus': 187,
+    'comma': 188,
+    'minus': 189,
+    'dot': 190,
+    'forwardslash': 191,
+    'graveaccent': 192,
+    'openbracket': 219,
+    'backslash': 220,
+    'closebracket': 221,
+    'singlequote': 222
+};
+
+/**
+ * KeyboardEvents class enables you to bind key action desired key combinations for ex., Ctrl+A, Delete, Alt+Space etc.
+ * ```html
+ * <div id='testEle'>  </div>;
+ * <script>
+ *   let node: HTMLElement = document.querySelector('#testEle');
+ *   let kbInstance = new KeyboardEvents({
+ *       element: node,
+ *       keyConfigs:{ selectAll : 'ctrl+a' },
+ *       keyAction: function (e:KeyboardEvent, action:string) {
+ *           // handler function code
+ *       }
+ *   });
+ * </script>
+ * ```
+ */
+@NotifyPropertyChanges
+export class KeyboardEvents extends Base<HTMLElement> implements INotifyPropertyChanged {
+
+    /**
+     * Specifies key combination and it respective action name.
+     *
+     * @default null
+     */
+    @Property({})
+    public keyConfigs: { [key: string]: string };
+
+    /**
+     * Specifies on which event keyboardEvents class should listen for key press. For ex., `keyup`, `keydown` or `keypress`
+     *
+     * @default keyup
+     */
+    @Property('keyup')
+    public eventName: string;
+
+    /**
+     * Specifies the listener when keyboard actions is performed.
+     *
+     * @event keyAction
+     */
+    @Event()
+    public keyAction: EmitType<KeyboardEventArgs>;
+
+    /**
+     * Initializes the KeyboardEvents
+     *
+     * @param {HTMLElement} element ?
+     * @param {KeyboardEventsModel} options ?
+     */
+    constructor(element: HTMLElement, options?: KeyboardEventsModel) {
+        super(options, element);
+        this.bind();
+    }
+
+    /**
+     * Unwire bound events and destroy the instance.
+     *
+     * @returns {void} ?
+     */
+    public destroy(): void {
+        this.unwireEvents();
+        super.destroy();
+    }
+
+    /**
+     * Function can be used to specify certain action if a property is changed
+     *
+     * @param {KeyboardEventsModel} newProp ?
+     * @param {KeyboardEventsModel} oldProp ?
+     * @returns {void} ?
+     * @private
+     */
+    // eslint-disable-next-line
+    public onPropertyChanged(newProp: KeyboardEventsModel, oldProp?: KeyboardEventsModel): void {
+        // No code are needed
+    }
+
+    protected bind(): void {
+        this.wireEvents();
+    }
+
+    /**
+     * To get the module name, returns 'keyboard'.
+     *
+     * @returns {string} ?
+     * @private
+     */
+    public getModuleName(): string {
+        return 'keyboard';
+    }
+
+    /**
+     * Wiring event handlers to events
+     *
+     * @returns {void} ?
+     * @private
+     */
+    private wireEvents(): void {
+        this.element.addEventListener(this.eventName, this.keyPressHandler);
+    }
+
+    /**
+     * Unwiring event handlers to events
+     *
+     * @returns {void} ?
+     * @private
+     */
+
+    private unwireEvents(): void {
+        this.element.removeEventListener(this.eventName, this.keyPressHandler);
+    }
+
+    /**
+     * To handle a key press event returns null
+     *
+     * @param {KeyboardEventArgs} e ?
+     * @returns {void} ?
+     */
+
+    private keyPressHandler: EventListener = (e: KeyboardEventArgs): void => {
+        const isAltKey: boolean = e.altKey;
+        const isCtrlKey: boolean = e.ctrlKey;
+        const isShiftKey: boolean = e.shiftKey;
+        const curkeyCode: number = e.which;
+        const keys: string[] = Object.keys(this.keyConfigs);
+        for (const key of keys) {
+            const configCollection: string[] = this.keyConfigs[`${key}`].split(',');
+            for (const rconfig of configCollection) {
+                const rKeyObj: KeyData = KeyboardEvents.getKeyConfigData(rconfig.trim());
+                if (isAltKey === rKeyObj.altKey && isCtrlKey === rKeyObj.ctrlKey &&
+                    isShiftKey === rKeyObj.shiftKey && curkeyCode === rKeyObj.keyCode) {
+                    e.action = key;
+                    if (this.keyAction) { this.keyAction(e); }
+                }
+            }
+        }
+    }
+
+    private static configCache: { [key: string]: KeyData } = {};
+
+    /**
+     * To get the key configuration data
+     *
+     * @param {string} config - configuration data
+     * @returns {KeyData} ?
+     */
+
+    private static getKeyConfigData(config: string): KeyData {
+        if (config in this.configCache) { return this.configCache[`${config}`]; }
+        const keys: string[] = config.toLowerCase().split('+');
+        const keyData: KeyData = {
+            altKey: (keys.indexOf('alt') !== -1 ? true : false),
+            ctrlKey: (keys.indexOf('ctrl') !== -1 ? true : false),
+            shiftKey: (keys.indexOf('shift') !== -1 ? true : false),
+            keyCode: null
+        };
+        if (keys[keys.length - 1].length > 1 && !!Number(keys[keys.length - 1])) {
+            keyData.keyCode = Number(keys[keys.length - 1]);
+
+        } else {
+            keyData.keyCode = KeyboardEvents.getKeyCode(keys[keys.length - 1]);
+        }
+        KeyboardEvents.configCache[`${config}`] = keyData;
+        return keyData;
+    }
+
+    // Return the keycode value as string
+    private static getKeyCode(keyVal: string): number {
+        return keyCode[`${keyVal}`] || keyVal.toUpperCase().charCodeAt(0);
+    }
+}
+
+interface KeyData {
+    altKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    keyCode: number | string;
+}
+