@dvrd/dvr-controls 1.0.14 → 1.0.16

package/src/js/util/miscUtil.ts

@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+import {IndexedObject} from "./interfaces";
+import React from "react";
+import DOMPurify from "dompurify";
+
+declare global {
+    // noinspection JSUnusedGlobalSymbols
+    interface Window {
+        log: Function;
+        settings: IndexedObject<any>;
+        allowCookies: boolean;
+        gtag?: Function;
+        gapi?: any;
+    }
+}
+
+export const getSetting = (name: string): any => {
+    const settings: IndexedObject<any> = window.settings;
+    if (settings.hasOwnProperty(name))
+        return settings[name];
+    console.warn(`Global settings does not contain a value for '${name}'`);
+}
+
+export const getMode = (): 'prod' | 'test' | 'dev' | 'accept' => {
+    return window.settings.mode;
+};
+
+export const log = (message: any, obj?: any, force: boolean = false) => {
+    if (getMode() !== 'prod' || force) {
+        if (obj !== undefined && obj !== null) console.log(message, obj);
+        else console.log(message);
+    }
+};
+
+export const warn = (message: string | number | boolean | object, obj?: any, force: boolean = false) => {
+    if (getMode() !== 'prod' || force) {
+        if (obj !== undefined && obj !== null) console.warn(message, obj);
+        else console.warn(message);
+    }
+};
+
+export const error = (message: string | number | boolean, obj?: any, force: boolean = false) => {
+    if (getMode() !== 'prod' || force) {
+        if (obj !== undefined && obj !== null) console.error(message, obj);
+        else console.error(message);
+    }
+};
+
+export const debug = (message: string | number | boolean | object, obj?: any, force: boolean = false) => {
+    if (getMode() !== 'prod' || force) {
+        if (obj !== undefined && obj !== null) console.debug(message, obj);
+        else console.debug(message);
+    }
+};
+
+const getRootFontSize = (): number => {
+    const root = document.documentElement,
+        fontString = window.getComputedStyle(root, null).getPropertyValue('font-size');
+    return parseInt(fontString.slice(0, fontString.length - 2), 10);
+};
+
+export const roundTo = (number: number, digits: number = 0): string => {
+    const isNegative = number < 0, multiplicator = Math.pow(10, digits);
+    if (isNegative) number = number * -1;
+    number = parseFloat((number * multiplicator).toFixed(11));
+    let numberString = (Math.round(number) / multiplicator).toFixed(digits);
+    if (isNegative)
+        numberString = (parseFloat(numberString) * -1).toFixed(digits);
+    return numberString;
+};
+
+export const roundToNumber = (number: number, decimals: number = 0): number => {
+    return Number(roundTo(number, decimals).replace(',', '.'));
+}
+
+export const parseMoney = (money: number): string => {
+    let moneyString: string;
+    if (money === 0 || money % 1 === 0) moneyString = money + ',-';
+    else moneyString = roundTo(money, 2).replace('.', ',');
+    if (/^0+[1-9]/.test(moneyString)) moneyString = moneyString.replace(/^0+/, '');
+    return moneyString;
+};
+
+export const capitalize = (text: string): string => text.length ?
+    text.substr(0, 1).toUpperCase() + text.substr(1) : text;
+
+export const getSearchParams = (search?: string, removeQuery: boolean = false): URLSearchParams => {
+    search = search === undefined || search === null ? location.search : search;
+    const params = new URLSearchParams(search);
+    if (removeQuery) window.history.pushState({}, document.title, window.location.pathname);
+    return params;
+};
+
+export const downloadFile = (blob: Blob, fileName: string) => {
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(blob);
+    link.type = 'download';
+    link.download = fileName;
+    link.click();
+};
+
+export const downloadRequiredFile = (path: string | { default: string }, fileName?: string) => {
+    if (typeof path !== 'string') path = path.default;
+    const name = getFileName(path, fileName);
+    const link = document.createElement('a');
+    link.href = path;
+    link.type = 'download';
+    link.download = name;
+    link.click();
+}
+
+const getFileName = (path: string, fileName?: string): string => {
+    if (fileName?.length) return fileName;
+    let pathName = path.substr(path.lastIndexOf('/') + 1, path.length);
+    const cacheReg = /-[a-zA-Z\d]+-cache/;
+    if (pathName.match(cacheReg))
+        pathName = pathName.replace(cacheReg, '');
+    return pathName;
+}
+
+export const preventDefault = (evt: Event | React.SyntheticEvent) => {
+    evt.preventDefault();
+};
+
+export const shuffleArray = (arr: any[]): any[] => {
+    let counter: number = arr.length;
+    if (counter === 0) return arr;
+    while (counter > 0) {
+        const randomIndex = Math.floor(Math.random() * counter--), temp = arr[counter];
+        arr[counter] = arr[randomIndex];
+        arr[randomIndex] = temp;
+    }
+    return arr;
+};
+
+export const nullify = <T extends string | Array<any>>(value?: T | null): T | null => {
+    return value?.length ? value : null;
+};
+
+export const undefine = (value?: string | null): string | undefined => {
+    return value?.length ? value : undefined;
+};
+
+export const sanitizeHtml = (html: string) => {
+    return DOMPurify().sanitize(html);
+};
+
+export const copyToClipboard = (text: string): Promise<void> => {
+    return copyClipboard(text);
+};
+
+export const copyClipboard = (text: string): Promise<void> => {
+    return window.navigator.clipboard.writeText(text);
+}
+
+export function webpSupported(): boolean {
+    try {
+        return document.createElement('canvas').toDataURL('image/webp')
+            .indexOf('data:image/webp') === 0;
+    } catch {
+        return false;
+    }
+}
+
+export function isAbsoluteLink(link: string): boolean {
+    return /^(https?|www).*/.test(link);
+}

package/src/js/util/momentUtil.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+import moment, {Moment} from "moment";
+
+export const MOMENT_FORMATS: string[] = [
+    'MM/DD/YYYY HH:mm:ss',
+    'MM-DD-YYYY HH:mm:ss',
+    'DD/MM/YYYY HH:mm:ss',
+    'DD-MM-YYYY HH:mm:ss',
+    'YYYY-MM-DD HH:mm:ss',
+    'YYYY/MM/DD HH:mm:ss',
+    'DD/MM/YYYYTHH:mm:ss',
+    'DD-MM-YYYYTHH:mm:ss',
+    'YYYY-MM-DDTHH:mm:ss',
+    'MM/DD/YYYY HH:mm',
+    'MM-DD-YYYY HH:mm',
+    'DD/MM/YYYY HH:mm',
+    'DD-MM-YYYY HH:mm',
+    'YYYY-MM-DD HH:mm',
+    'YYYY/MM/DD HH:mm',
+    'DD/MM/YYYYTHH:mm',
+    'DD-MM-YYYYTHH:mm',
+    'YYYY-MM-DDTHH:mm',
+    'YYYY/MM/DDTHH:mm',
+    'YYYY-MM-DD',
+    'YYYY/MM/DD',
+    'MM-DD-YYYY',
+    'MM/DD/YYYY',
+    'DD-MM-YYYY',
+    'DD/MM/YYYY',
+];
+
+export const toMoment = (dateValue?: string | Moment | null | Date, formats: string[] | string = MOMENT_FORMATS): Moment => {
+    if (moment.isMoment(dateValue)) return dateValue;
+    if(dateValue instanceof Date) return moment(dateValue);
+    if (!dateValue || !dateValue.length) return moment();
+    return moment(dateValue, formats);
+};
+
+export const formatMoment = (date?: Moment, format: string = 'YYYY-MM-DDTHH:mm:ss'): string => {
+    if (!date) date = toMoment();
+    return date.format(format);
+};

package/src/js/util/pdfUtil.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+import {DefaultPDFElementParams, IndexedObject, PdfFont, PDFTextVariables, SelectItemShape} from "./interfaces";
+
+export const mmToPt = (mm: number) => Math.round(pxToPt(mmToPx(mm)));
+export const mmToPx = (mm: number, toTens: boolean = true) => {
+    const value: number = Math.round(mm / 0.264583333);
+    return toTens ? roundToTens(value) : value;
+}
+export const pxToMm = (pixels: number) => Math.round(pixels * 0.264583333);
+export const pxToPt = (px: number) => Math.round(px * .75);
+export const ptToPx = (pt: number, toTens: boolean = true) => {
+    const value: number = Math.round(pt / .75);
+    return toTens ? roundToTens(value) : value;
+}
+export const ptToMm = (pt: number) => pxToMm(ptToPx(pt));
+export const PAGE_WIDTH = 794, PAGE_HEIGHT = 1122; // In pixels
+
+export const PDF_VARIABLES: PDFTextVariables = {
+    company: {
+        bedrijf_naam: 'Bedrijfsnaam',
+        bedrijf_adres: 'Adres',
+        bedrijf_postcode: 'Postcode',
+        bedrijf_stad: 'Stad',
+        bedrijf_land: 'Land',
+        bedrijf_email: 'E-mailadres',
+        bedrijf_telefoon: 'Telefoonnummer',
+        bedrijf_iban: 'IBAN',
+        bedrijf_btw: 'BTW-nummer',
+        bedrijf_kvk: 'KvK nummer'
+    },
+    client: {
+        klant_naam: 'Klantnaam',
+        klant_adres: 'Adres',
+        klant_postcode: 'Postcode',
+        klant_stad: 'Stad',
+        klant_land: 'Land',
+        klant_extra: 'Adres toevoeging',
+        klant_email: 'E-mailadres',
+        klant_telefoon: 'Telefoonnummer',
+        // klant_iban: 'IBAN',
+        klant_btw: 'BTW-nummer',
+        klant_kvk: 'KvK nummer',
+        klant_bedrijf: 'Bedrijfsnaam',
+    },
+    invoice: {
+        datum: 'Huidige datum',
+        factuurnummer: 'Factuurnummer',
+        subtotaal: 'Subtotaal',
+        btw_totaal: 'Totaal BTW (\u20ac)',
+        factuurtotaal: 'Factuurtotaal',
+        factuurdatum: 'Factuur datum',
+        factuurref: 'Factuur referentie'
+    }
+}
+
+export const getPdfVariables = (customVariables?: PDFTextVariables): PDFTextVariables => {
+    const variables = PDF_VARIABLES;
+    if (customVariables) {
+        const {company, invoice, client} = customVariables;
+        for (const key of Object.keys(company))
+            variables.company[key] = company[key];
+        for (const key of Object.keys(invoice))
+            variables.invoice[key] = invoice[key];
+        for (const key of Object.keys(client))
+            variables.client[key] = client[key];
+    }
+    return variables;
+}
+
+export const setPdfVariables = (text: string, values: IndexedObject<string>) => {
+    for (const key of Object.keys(values)) {
+        const value = values[key];
+        if (text.includes(`{${key}}`) && value.length) text =
+            text.replace(new RegExp('\{' + key + '\}', 'g'), value);
+    }
+    return text;
+};
+
+export const setElementSettings = (element: DefaultPDFElementParams<any, any>, convertUnits: boolean = true) => {
+    const {dimensions, options} = element;
+    if (convertUnits) {
+        if (dimensions?.width) dimensions.width = ptToPx(dimensions.width, false);
+        if (dimensions?.height) dimensions.height = ptToPx(dimensions.height, false);
+        if (options?.fontSize) options.fontSize = ptToPx(element.options.fontSize, false);
+    }
+};
+
+export const fontItems: SelectItemShape[] = [
+    {label: 'Helvetica', value: PdfFont.HELVETICA, labelStyle: {fontFamily: 'helvetica'}},
+    {label: 'Lato', value: PdfFont.LATO, labelStyle: {fontFamily: 'lato'}},
+    {label: 'Merriweather', value: PdfFont.MERRIWEATHER, labelStyle: {fontFamily: 'merriweather'}},
+    {label: 'Noto Sans', value: PdfFont.NOTO_SANS, labelStyle: {fontFamily: 'noto-sans'}},
+    {label: 'Noto Serif', value: PdfFont.NOTO_SERIF, labelStyle: {fontFamily: 'noto-serif'}},
+    {label: 'Open Sans', value: PdfFont.OPEN_SANS, labelStyle: {fontFamily: 'open-sans'}},
+    {label: 'Playfair Display', value: PdfFont.PLAYFAIR, labelStyle: {fontFamily: 'playfair'}},
+    {label: 'PT Serif', value: PdfFont.PT_SERIF, labelStyle: {fontFamily: 'pt-serif'}},
+    {label: 'Roboto', value: PdfFont.ROBOTO, labelStyle: {fontFamily: 'roboto'}},
+    {label: 'Roboto Mono', value: PdfFont.ROBOTO_MONO, labelStyle: {fontFamily: 'roboto-mono'}},
+    {label: 'Source Sans Pro', value: PdfFont.SOURCE_SANS_PRO, labelStyle: {fontFamily: 'source-sans-pro'}}
+];
+
+export const parsePrice = (price: number) => {
+    return price.toFixed(2).replace('.', ',').replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+};
+
+const roundToTens = (value: number): number => {
+    const remainder = value % 10;
+    if (remainder === 0) return value;
+    if (remainder > 4) return value + (10 - remainder);
+    return value - remainder;
+};
+
+export const waitForFonts = (callback: Function) => {
+    // @ts-ignore
+    if (document.fonts && document.fonts.ready) {
+        // @ts-ignore
+        document.fonts.ready.then(() => {
+            callback();
+        });
+    }
+};

package/src/js/util/requestUtil.ts

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+import {OutgoingHttpHeaders} from "http";
+import {showDialog} from './eventUtil';
+import {warn} from "./miscUtil";
+import {FetchMethod, ResponseData} from './interfaces';
+import {getJwt} from './jwtUtil';
+import {voidFunction} from "./controlUtil";
+
+type ResponseHandler = (response: Response, config: FetchOptions) => void;
+
+export interface FetchOptions {
+    baseUrl?: string | null;
+    url: string;
+    method?: FetchMethod;
+    data?: {};
+    stringifyData?: boolean;
+    headers?: OutgoingHttpHeaders;
+    callback?: Function;
+    errorCallback?: (response: Response | string) => void;
+    credentials?: string;
+    responseParser?: ResponseHandler;
+    errorHandler?: ResponseHandler;
+}
+
+let abortController: AbortController;
+let signal: AbortSignal;
+let defaultHeaders: OutgoingHttpHeaders = {};
+let defaultErrorHandler: ResponseHandler | null = null;
+
+function getAbortController(): AbortController | null {
+    try {
+        if (!('AbortController' in window)) return null;
+        return new AbortController();
+    } catch {
+        return null;
+    }
+}
+
+const responseDataIsSuccess = (data: ResponseData): boolean => data.status === 'success';
+
+export const setDefaultHeaders = (headers: OutgoingHttpHeaders) => {
+    defaultHeaders = headers;
+}
+
+export function setDefaultErrorHandler(errorHandler: ResponseHandler | null) {
+    defaultErrorHandler = errorHandler;
+}
+
+/**
+ * Cancel all running requests and refresh the abort controller and signal
+ */
+export const cancelAllFetch = () => {
+    if (abortController) {
+        abortController.abort();
+        abortController = new AbortController;
+        signal = abortController.signal;
+    }
+};
+
+export function sendFetch(config: FetchOptions, legacySupport: boolean = false): AbortController | null {
+    const baseUrl = config.baseUrl || window.settings.platformUrl;
+    if (!baseUrl) throw new Error('Base url is not set!');
+
+    config = _prepareConfig(config, legacySupport);
+    const {url, method, headers, data} = config;
+    const options: { [index: string]: any } = {
+        headers,
+        method,
+        body: config.stringifyData === false ? data : JSON.stringify(data),
+        cache: 'no-store',
+    };
+    const abortController = getAbortController();
+    if (abortController) options.signal = abortController.signal;
+
+    options['mode'] = 'cors';
+    fetch(baseUrl + url, options).then((response: Response) => {
+        _handleResponse(response, config);
+    }).catch((reason: any) => {
+        if (reason.code === DOMException.ABORT_ERR) {/*Request aborted*/
+        } else if (config.errorCallback)
+            config.errorCallback(reason);
+    });
+    return abortController;
+}
+
+function _handleResponse(response: Response, config: FetchOptions) {
+    if (config.responseParser)
+        return config.responseParser(response, config);
+
+    if (response.ok) {
+        if (!config.callback) return;
+        if (response.headers.get('content-type') === 'application/json') {
+            response.json().then((data: any) => {
+                if (data.message === 'Invalid rights') {
+                    showDialog('Je hebt niet genoeg rechten voor deze actie.');
+                    data.handled = true;
+                    if (config.callback) config.callback(data);
+                } else if (config.callback) {
+                    data.success = responseDataIsSuccess(data);
+                    config.callback(data);
+                }
+            });
+        } else config.callback(response);
+    } else
+        _onErrorResponse(response, config);
+}
+
+function _onErrorResponse(response: Response, config: FetchOptions) {
+    if (config.errorHandler) config.errorHandler(response, config);
+    else if (config.errorCallback) config.errorCallback(response);
+    else if (config.callback) config.callback({status: 'error', message: 'Er is iets misgegaan in het systeem.'});
+}
+
+function _prepareConfig(options: FetchOptions, legacySupport: boolean = true): FetchOptions {
+    const fetchOptions: FetchOptions = Object.assign({}, options);
+    if (!fetchOptions.method) fetchOptions.method = FetchMethod.GET;
+    if (!fetchOptions.callback) fetchOptions.callback = voidFunction;
+
+    if ([FetchMethod.POST, FetchMethod.PUT].includes(fetchOptions.method) && !fetchOptions.data)
+        throw new Error('Cannot send POST or PUT without data.');
+    else if (fetchOptions.method === FetchMethod.GET && fetchOptions.data)
+        warn('Cannot send data with GET requests, data will be ignored.');
+
+    if (fetchOptions.credentials === undefined) fetchOptions.credentials = 'same-origin';
+
+    if (legacySupport && fetchOptions.callback) {
+        const legacyCallback = fetchOptions.callback;
+        fetchOptions.callback = (data: ResponseData) => {
+            legacyCallback({data});
+        }
+    }
+    return setAuthHeader(fetchOptions);
+}
+
+function setAuthHeader(options: FetchOptions): FetchOptions {
+    const headers: OutgoingHttpHeaders = Object.assign({}, defaultHeaders, options.headers || {});
+    const jwt = getJwt();
+    if (jwt)
+        headers.Authorization = `JWT ${jwt}`;
+    options.headers = headers;
+    return options;
+}

package/src/js/util/responsiveUtil.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+import {Breakpoint} from "./interfaces";
+import {warn} from "./miscUtil";
+
+export const getScreenWidth = (includeScrollBars: boolean = false): number => {
+    if (includeScrollBars)
+        return document.documentElement.offsetWidth || 0;
+    return Math.min(document.documentElement.clientWidth, window.innerWidth || 0);
+};
+
+export const getScreenHeight = (): number => Math.min(document.documentElement.clientHeight, window.innerHeight || 0);
+
+export const getBreakPoint = (): Breakpoint => {
+    const screenWidth: number = getScreenWidth();
+    if (screenWidth >= Breakpoint.XL) return Breakpoint.XL;
+    if (screenWidth >= Breakpoint.LG) return Breakpoint.LG;
+    if (screenWidth >= Breakpoint.MD) return Breakpoint.MD;
+    if (screenWidth >= Breakpoint.SM) return Breakpoint.SM;
+    return Breakpoint.XS;
+};
+
+export const deviceIsMobile = (): boolean => {
+    return window.matchMedia(`(max-width: ${Breakpoint.SM}px)`).matches;
+};
+
+export const matchBreakpoint = (breakPoint: Breakpoint, matchType: 'less' | 'more' = 'less',
+                                allowEqual: boolean = true): boolean => {
+    if (breakPoint === Breakpoint.XS) warn(
+        'Do not use Breakpoint.XS for matching breakpoints. Breakpoint.XS is equal to 0');
+    const actualBreakpoint: Breakpoint = getBreakPoint();
+    if (breakPoint === actualBreakpoint) return allowEqual;
+    else if (matchType === 'less') return actualBreakpoint < breakPoint;
+    else return actualBreakpoint > breakPoint;
+};

package/src/js/util/validationUtil.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+export const validateEmail = (email: string, allowMultiple?: boolean): boolean =>
+    allowMultiple ? validateMultipleEmails(email) :
+    /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(
+        email);
+
+function validateMultipleEmails(emails: string): boolean {
+    return /^(,?(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,})))+$/.test(
+        emails);
+}

package/src/style/common-icons-variables.scss

@@ -0,0 +1,140 @@
+/*!
+ * Copyright (c) 2021. Dave van Rijn Development
+ */
+
+$icomoon-font-path: "./fonts" !default;
+
+$common-icon-education-2: "\e95f";
+$common-icon-suitcase: "\e910";
+$common-icon-facebook: "\e95e";
+$common-icon-instagram: "\e964";
+$common-icon-linkedin: "\e965";
+$common-icon-sms3: "\e958";
+$common-icon-calender: "\e956";
+$common-icon-dashboard: "\e957";
+$common-icon-email: "\e959";
+$common-icon-messenger: "\e95a";
+$common-icon-sms: "\e95b";
+$common-icon-triangle: "\e95c";
+$common-icon-whatsapp: "\e95d";
+$common-icon-arrow_bothways: "\e955";
+$common-icon-note: "\e947";
+$common-icon-contact: "\e94e";
+$common-icon-files: "\e94f";
+$common-icon-alarm: "\e950";
+$common-icon-bar-magnifier: "\e954";
+$common-icon-course: "\e94b";
+$common-icon-recovery-place: "\e948";
+$common-icon-orthodontist: "\e949";
+$common-icon-ying-yang: "\e94a";
+$common-icon-star-half: "\e952";
+$common-icon-star-full: "\e945";
+$common-icon-star-empty: "\e946";
+$common-icon-acne: "\e953";
+$common-icon-anti-conception: "\e960";
+$common-icon-edit: "\e968";
+$common-icon-feetcare: "\e969";
+$common-icon-info: "\e96c";
+$common-icon-medical-supply: "\e96d";
+$common-icon-medicine: "\e96e";
+$common-icon-piggy-bank: "\e96f";
+$common-icon-dentist: "\e94c";
+$common-icon-pregnancy-care: "\e94d";
+$common-icon-physio: "\e951";
+$common-icon-trash: "\e944";
+$common-icon-book: "\e943";
+$common-icon-file-checklist: "\e941";
+$common-icon-safe: "\e942";
+$common-icon-bike: "\e919";
+$common-icon-boiler: "\e91a";
+$common-icon-camera-2: "\e91b";
+$common-icon-camping-equipment: "\e91c";
+$common-icon-caravan: "\e91d";
+$common-icon-couche: "\e91e";
+$common-icon-desktop: "\e91f";
+$common-icon-display: "\e920";
+$common-icon-document-2: "\e921";
+$common-icon-dumbbell: "\e922";
+$common-icon-education: "\e923";
+$common-icon-electronics: "\e924";
+$common-icon-glasses: "\e925";
+$common-icon-glue: "\e926";
+$common-icon-gramophone: "\e927";
+$common-icon-health-insurance: "\e928";
+$common-icon-hearing-aid: "\e929";
+$common-icon-kitchen-mixer: "\e92a";
+$common-icon-laptop: "\e92b";
+$common-icon-medical: "\e92c";
+$common-icon-mobile-2: "\e92d";
+$common-icon-mobile: "\e92e";
+$common-icon-moped-front: "\e92f";
+$common-icon-moped: "\e930";
+$common-icon-motor-helmet: "\e931";
+$common-icon-personal-info: "\e932";
+$common-icon-radio: "\e933";
+$common-icon-sailing-boat: "\e934";
+$common-icon-ski: "\e935";
+$common-icon-sofa: "\e936";
+$common-icon-sport-shirt: "\e937";
+$common-icon-sport-shoes: "\e938";
+$common-icon-tablet: "\e939";
+$common-icon-tax-office: "\e93a";
+$common-icon-tax: "\e93b";
+$common-icon-tent-2: "\e93c";
+$common-icon-tent: "\e93d";
+$common-icon-tv: "\e93e";
+$common-icon-vacuum-cleaner: "\e93f";
+$common-icon-work-office: "\e940";
+$common-icon-profile: "\e918";
+$common-icon-car-speed-gauge: "\e915";
+$common-icon-file-add: "\e916";
+$common-icon-travel-beach: "\e917";
+$common-icon-banking-spending: "\e914";
+$common-icon-car: "\e913";
+$common-icon-first-aid-kit: "\e901";
+$common-icon-money-bag: "\e902";
+$common-icon-pasport: "\e903";
+$common-icon-home: "\e904";
+$common-icon-travel-insurance: "\e905";
+$common-icon-clock: "\e906";
+$common-icon-alarm-clock: "\e907";
+$common-icon-sms2: "\e908";
+$common-icon-email2: "\e909";
+$common-icon-check: "\e90a";
+$common-icon-plus: "\e90b";
+$common-icon-document: "\e90c";
+$common-icon-arrow-left: "\e90d";
+$common-icon-arrow-right: "\e90e";
+$common-icon-person: "\e90f";
+$common-icon-world: "\e911";
+$common-icon-user2: "\e912";
+$common-icon-camera: "\e963";
+$common-icon-bulb: "\e962";
+$common-icon-folder-open2: "\e961";
+$common-icon-play: "\ea15";
+$common-icon-excel: "\e900";
+$common-icon-powerpoint: "\e966";
+$common-icon-word: "\e967";
+$common-icon-pdf: "\e96a";
+$common-icon-caret-down: "\f0d7";
+$common-icon-th-large: "\f009";
+$common-icon-th-list: "\f00b";
+$common-icon-image: "\f03e";
+$common-icon-user3: "\f008";
+$common-icon-lock2: "\f024";
+$common-icon-shield2: "\f133";
+$common-icon-email-2: "\e96b";
+$common-icon-sms-2: "\e970";
+$common-icon-menu: "\f0c9";
+$common-icon-euro: "\f153";
+$common-icon-pin: "\f08e";
+$common-icon-back: "\f112";
+$common-icon-student: "\e971";
+$common-icon-youngprof: "\e972";
+$common-icon-cross: "\e973";
+$common-icon-opera: "\f26a";
+$common-icon-safari: "\f267";
+$common-icon-chrome: "\f268";
+$common-icon-firefox: "\f269";
+$common-icon-list-numbered: "\e9b9";
+