wg5 0.0.1-security → 8.462.0

package/src/modules/organisms/header/scripts/a11y-navigation/PopupMenu.js

@@ -0,0 +1,230 @@
+import { MenuItem } from './MenuItem';
+
+export class PopupMenu {
+    constructor(domNode, controllerObj) {
+        let elementChildren,
+            msgPrefix = 'PopupMenu constructor argument domNode ';
+
+        // Check whether domNode is a DOM element
+        if (!domNode instanceof Element) {
+            throw new TypeError(msgPrefix + 'is not a DOM Element.');
+        }
+        // Check whether domNode has child elements
+        if (domNode.childElementCount === 0) {
+            throw new Error(msgPrefix + 'has no element children.');
+        }
+        // Check whether domNode descendant elements have A elements
+        let childElement = domNode.firstElementChild;
+        while (childElement) {
+            let menuitem = childElement.firstElementChild;
+            if (menuitem && menuitem === 'A') {
+                throw new Error(msgPrefix + 'has descendant elements that are not A elements.');
+            }
+            childElement = childElement.nextElementSibling;
+        }
+
+        this.isMenubar = false;
+
+        this.domNode = domNode;
+        this.controller = controllerObj;
+
+        this.menuitems = []; // See PopupMenu init method
+        this.firstChars = []; // See PopupMenu init method
+
+        this.firstItem = null; // See PopupMenu init method
+        this.lastItem = null; // See PopupMenu init method
+
+        this.hasFocus = false; // See MenuItem handleFocus, handleBlur
+        this.hasHover = false; // See PopupMenu handleMouseover, handleMouseout
+    }
+
+    init() {
+        let childElement, menuElement, menuItem, textContent, numItems, label;
+
+        // Configure the domNode itself
+
+        this.domNode.parentNode.addEventListener('mouseover', this.handleMouseover.bind(this));
+        this.domNode.parentNode.addEventListener('mouseout', (event) => {
+            this.handleMouseout(event);
+        });
+
+        // Traverse the element children of domNode: configure each with
+        // menuitem role behavior and store reference in menuitems array.
+        childElement = this.domNode.querySelectorAll('.header-nav-sub-menu__item');
+
+        [].forEach.call(childElement, (element) => {
+            menuElement = element.firstElementChild;
+
+            if (menuElement && menuElement.tagName === 'A') {
+                menuItem = new MenuItem(menuElement, this);
+                menuItem.init();
+                this.menuitems.push(menuItem);
+                textContent = menuElement.textContent.trim();
+                this.firstChars.push(textContent.substring(0, 1).toLowerCase());
+            }
+        });
+
+        // Use populated menuitems array to initialize firstItem and lastItem.
+        numItems = this.menuitems.length;
+        if (numItems > 0) {
+            this.firstItem = this.menuitems[0];
+            this.lastItem = this.menuitems[numItems - 1];
+        }
+    }
+
+    handleMouseover() {
+        this.hasHover = true;
+    }
+
+    handleMouseout(event) {
+        let currentTarget = event.currentTarget;
+
+        if (!currentTarget.contains(event.relatedTarget)) {
+            this.hasHover = false;
+            this.close(false);
+        }
+    }
+
+    setFocusToController(command, flag) {
+        if (typeof command !== 'string') {
+            command = '';
+        }
+
+        function setFocusToMenubarItem(controller, close) {
+            while (controller) {
+                if (controller.isMenubarItem) {
+                    controller.domNode.focus();
+                    return controller;
+                } else {
+                    if (close) {
+                        controller.menu.close(true);
+                    }
+                    controller.hasFocus = false;
+                }
+                controller = controller.menu.controller;
+            }
+            return false;
+        }
+
+        if (command === '') {
+            if (this.controller && this.controller.domNode) {
+                this.controller.domNode.focus();
+            }
+            return;
+        }
+
+        if (!this.controller.isMenubarItem) {
+            this.controller.domNode.focus();
+            this.close();
+
+            if (command === 'next') {
+                let menubarItem = setFocusToMenubarItem(this.controller, false);
+                if (menubarItem) {
+                    menubarItem.menu.setFocusToNextItem(menubarItem, flag);
+                }
+            }
+        } else {
+            if (command === 'previous') {
+                this.controller.menu.setFocusToPreviousItem(this.controller, flag);
+            } else if (command === 'next') {
+                this.controller.menu.setFocusToNextItem(this.controller, flag);
+            }
+        }
+    }
+
+    setFocusToFirstItem() {
+        this.firstItem.domNode.focus();
+    }
+
+    setFocusToLastItem() {
+        this.lastItem.domNode.focus();
+    }
+
+    setFocusToPreviousItem(currentItem) {
+        let index;
+
+        if (currentItem === this.firstItem) {
+            this.lastItem.domNode.focus();
+        } else {
+            index = this.menuitems.indexOf(currentItem);
+            this.menuitems[index - 1].domNode.focus();
+        }
+    }
+
+    setFocusToNextItem(currentItem) {
+        let index;
+
+        if (currentItem === this.lastItem) {
+            this.firstItem.domNode.focus();
+        } else {
+            index = this.menuitems.indexOf(currentItem);
+            this.menuitems[index + 1].domNode.focus();
+        }
+    }
+
+    setFocusByFirstCharacter(currentItem, char) {
+        let start,
+            index,
+            lowerCasedChar = char.toLowerCase();
+
+        // Get start index for search based on position of currentItem
+        start = this.menuitems.indexOf(currentItem) + 1;
+        if (start === this.menuitems.length) {
+            start = 0;
+        }
+
+        // Check remaining slots in the menu
+        index = this.getIndexFirstChars(start, lowerCasedChar);
+
+        // If not found in remaining slots, check from beginning
+        if (index === -1) {
+            index = this.getIndexFirstChars(0, lowerCasedChar);
+        }
+
+        // If match was found...
+        if (index > -1) {
+            this.menuitems[index].domNode.focus();
+        }
+    }
+
+    getIndexFirstChars(startIndex, char) {
+        for (let i = startIndex; i < this.firstChars.length; i++) {
+            if (char === this.firstChars[i]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    open() {
+        this.domNode.parentNode.classList.add('header-menu__item--opened');
+        this.controller.setExpanded(true);
+    }
+
+    close(force) {
+        let controllerHasHover = this.controller.hasHover;
+
+        let hasFocus = this.hasFocus;
+
+        for (let i = 0; i < this.menuitems.length; i++) {
+            let mi = this.menuitems[i];
+            if (mi.popupMenu) {
+                hasFocus = hasFocus | mi.popupMenu.hasFocus;
+            }
+        }
+
+        if (!this.controller.isMenubarItem) {
+            controllerHasHover = false;
+        }
+
+        if (force || (!hasFocus && !this.hasHover && !controllerHasHover)) {
+            this.domNode.parentNode.classList.remove('header-menu__item--opened');
+            this.controller.setExpanded(false);
+        }
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/modules/organisms/header/scripts/a11y-navigation/PopupMenu.js

package/src/modules/organisms/header/scripts/a11y-navigation/helpers.js

@@ -0,0 +1,23 @@
+export function isPrintableCharacter(str) {
+    return str.length === 1 && str.match(/\S/);
+}
+
+export const keyCode = Object.freeze({
+    TAB: 9,
+    RETURN: 13,
+    ESC: 27,
+    SPACE: 32,
+    PAGEUP: 33,
+    PAGEDOWN: 34,
+    END: 35,
+    HOME: 36,
+    LEFT: 37,
+    UP: 38,
+    RIGHT: 39,
+    DOWN: 40,
+});
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/modules/organisms/header/scripts/a11y-navigation/helpers.js

package/src/services/cookie.js

@@ -0,0 +1,18 @@
+export class CookieService {
+    static getCookie(name) {
+        // TODO: update cookies methods not from WG3
+        // https://www.wrike.com/open.htm?id=522917906
+        return WG.utils.getCookie(name);
+    }
+    static setCookie(name, value, options = {}) {
+        WG.utils.setCookie(name, value, options);
+    }
+    static deleteCookie(name) {
+        return WG.utils.deleteCookie(name);
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/services/cookie.js

package/src/services/geo.js

@@ -0,0 +1,17 @@
+import { CookieService } from './cookie';
+
+export class GeoService {
+    static get country() {
+        return CookieService.getCookie('country');
+    }
+    static get countryCode() {
+        const countryCookie = GeoService.country || 'US:::';
+
+        return countryCookie.split(':')[0];
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/services/geo.js

package/src/services/phone.js

@@ -0,0 +1,38 @@
+import {
+    parsePhoneNumberFromString,
+    parseIncompletePhoneNumber,
+    getExampleNumber,
+    isSupportedCountry,
+} from 'libphonenumber-js/min';
+import { GeoService } from './geo';
+
+import examples from 'libphonenumber-js/examples.mobile.json';
+
+export class PhoneService {
+    constructor() {
+        this.countryCode = GeoService.countryCode;
+
+        if (isSupportedCountry(this.countryCode) === false) {
+            this.countryCode = 'US';
+        }
+    }
+
+    format(text) {
+        let formattedPhone = parsePhoneNumberFromString(text, this.countryCode);
+
+        if (!formattedPhone) {
+            return parseIncompletePhoneNumber(text);
+        }
+
+        return formattedPhone.formatInternational();
+    }
+
+    getExample() {
+        return getExampleNumber(this.countryCode, examples).formatInternational();
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/services/phone.js

package/src/services/registration.js

@@ -0,0 +1,71 @@
+import { stringToLowerCase } from '../global/js/helper/stringToLowerCase';
+
+export class RegistrationService {
+    static register(email, formName, plan = 'pro', promocode, addons, packages, source, registrationType, template) {
+        return new Promise((resolve, reject) => {
+            const registration = new WG.RebrandingRegistration({
+                fields: {
+                    registrationType: true,
+                    licenseId: true,
+                },
+            });
+
+            plan = stringToLowerCase(plan);
+
+            registration.setOptions({
+                locale: window.wrike.locale,
+                fields: {
+                    registrationType: registrationType,
+                    source: source,
+                    promoCode: promocode,
+                    packages: packages,
+                    addons: addons,
+                    plan: plan,
+                    template: template,
+                },
+            });
+            registration
+                .register(email, formName, plan)
+                .then((response) => {
+                    registration.signupSuccessHandler(response);
+                    resolve(response);
+                })
+                .fail((response) => {
+                    reject(response);
+                });
+        });
+    }
+
+    static registerNewContract(email, formName, plan, addons, packages, source, template, promocode, onboarding) {
+        return new Promise((resolve, reject) => {
+            const registration = new WG.RebrandingRegistrationNewContract();
+
+            registration.setOptions({
+                locale: window.wrike.locale,
+                fields: {
+                    plan: plan,
+                    addons: addons,
+                    packages: packages,
+                    template: template,
+                    source: source,
+                    promoCode: promocode,
+                    onboarding: onboarding,
+                },
+            });
+            registration
+                .register(email)
+                .then((response) => {
+                    registration.signupSuccessHandler(response);
+                    resolve(response);
+                })
+                .fail((response) => {
+                    reject(response);
+                });
+        });
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/services/registration.js

package/src/services/tracking.js

@@ -0,0 +1,27 @@
+import WG from '../global/js/wg';
+
+export class TrackingService {
+    /**
+     * trackEventForm
+     * @param {object} options - Options
+     * @param {boolean} enqueue - Enqueue
+     * @return {Promise}
+     * */
+    static trackEventForm(options, enqueue = true) {
+        const tracking = new WG.Tracking(options);
+        return tracking.send(enqueue);
+    }
+
+    /**
+     * trackAirPr
+     * @param {object} options - Options
+     * */
+    static trackAirPr(options) {
+        new WG.AirPrTracking(options);
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/services/tracking.js

package/src/validators/validate.js

@@ -0,0 +1,100 @@
+function isEmptyInputValue(value) {
+    return value === null || value.length === 0;
+}
+const EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+export class Validators {
+    static min(min) {
+        return (control) => {
+            if (isEmptyInputValue(control) || isEmptyInputValue(min)) {
+                return null;
+            }
+            const value = parseFloat(control);
+
+            return !isNaN(value) && value < min ? { min: { min: min, actual: control } } : null;
+        };
+    }
+
+    static max(max) {
+        return (control) => {
+            if (isEmptyInputValue(control) || isEmptyInputValue(max)) {
+                return null;
+            }
+            const value = parseFloat(control);
+
+            return !isNaN(value) && value > max ? { max: { max: max, actual: control } } : null;
+        };
+    }
+
+    static required(control) {
+        return isEmptyInputValue(control) ? { required: true } : null;
+    }
+
+    static requiredTrue(control) {
+        return control === true ? null : { required: true };
+    }
+
+    static email(control) {
+        if (isEmptyInputValue(control)) {
+            return null;
+        }
+        return EMAIL_REGEXP.test(control) ? null : { email: true };
+    }
+
+    static minLength(minLength) {
+        return (control) => {
+            if (isEmptyInputValue(control)) {
+                return null;
+            }
+            const length = control ? control.length : 0;
+
+            return length < minLength ? { minlength: { requiredLength: minLength, actualLength: length } } : null;
+        };
+    }
+
+    static maxLength(maxLength) {
+        return (control) => {
+            const length = control ? control.length : 0;
+
+            return length > maxLength ? { maxlength: { requiredLength: maxLength, actualLength: length } } : null;
+        };
+    }
+
+    static pattern(pattern) {
+        if (!pattern) return Validators.nullValidator;
+        let regex;
+        let regexStr;
+
+        if (typeof pattern === 'string') {
+            regexStr = '';
+
+            if (pattern.charAt(0) !== '^') regexStr += '^';
+
+            regexStr += pattern;
+
+            if (pattern.charAt(pattern.length - 1) !== '$') regexStr += '$';
+
+            regex = new RegExp(regexStr);
+        } else {
+            regexStr = pattern.toString();
+            regex = pattern;
+        }
+        return (control) => {
+            if (isEmptyInputValue(control)) {
+                return null;
+            }
+            const value = control;
+
+            return regex.test(value) ? null : { pattern: { requiredPattern: regexStr, actualValue: value } };
+        };
+    }
+
+    static nullValidator() {
+        return null;
+    }
+}
+
+
+
+// WEBPACK FOOTER //
+// ./node_modules/wg5/src/validators/validate.js

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=wg5 for more information.