@colijnit/sharedcomponents 1.0.23 → 1.0.25

package/projects/sharedcomponents/src/lib/utils/array-utils.ts

@@ -0,0 +1,202 @@
+import {ObjectUtils} from "@colijnit/articleapi/build/utils/object-utils";
+import {NumberUtils} from "@colijnit/articleapi/build/utils/number-utils";
+import {isNill} from "@colijnit/articleapi/build/utils/function/is-nill.function";
+import {notNill} from "@colijnit/articleapi/build/utils/function/not-nill.function";
+
+export class ArrayUtils {
+    /**
+     * Returns whether at least one element in given array could be found by given finder function.
+     *
+     * @param {T[]} array
+     * @param {(element: T) => boolean} finder A finder function that takes an element of the array and returns a boolean that represents
+     * the 'found status' for that element; whether it should have been found or not.
+     */
+    public static ContainsAnElementFoundBy<T>(array: T[], finder: (element: T) => boolean): boolean {
+        if (!array || !finder) {
+            return false;
+        }
+
+        return notNill(this.Find<T>(array, finder));
+    }
+
+    /**
+     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns
+     * undefined when none was found.
+     *
+     * Example usage:
+     * const foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>
+     *     (return modelItem.getId() === '1')
+     *   * });
+     *
+     * @param array The array with items to search in.
+     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.
+     */
+    public static Find<T>(array: T[], foundBy: (item: T) => boolean): T {
+        if (!array || !foundBy) {
+            return undefined;
+        }
+
+        for (let i: number = 0, len: number = array.length; i < len; i++) {
+            const itemCur: T = array[i];
+            if (foundBy(itemCur) ) {
+                return itemCur;
+            }
+        }
+        return undefined;
+    }
+
+    // @returns empty array when nothing found, otherwise array with found items
+    public static FindAll<T>(array: T[], foundBy: (item: T) => boolean): T[] {
+        const answer: T[] = [];
+        if (!array || !foundBy) {
+            return answer;
+        }
+
+        for (let i: number = 0, len: number = array.length; i < len; i++) {
+            const itemCur: T = array[i];
+            if (foundBy(itemCur)) {
+                answer.push(itemCur);
+            }
+        }
+        return answer;
+    }
+
+    // returns a simple clone of given array, using array.slice(0)
+    public static CloneArray<T>(array: T[]): T[] {
+        let answer: T[] = [];
+
+        if (array) {
+            answer = array.slice(0);
+        }
+
+        return answer;
+    }
+
+    /**
+     * Returns a 'semi deep clone' of given array. Its first-level members are object-shallow-cloned (optionally with a strongly typed constructor),
+     * or just as plain object (see param arrayItemsClass).
+     * @param array
+     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise
+     * it'll be a plain object.
+     * @param deepClone Set to true if array items contain FUNCTIONS that need to be cloned..
+     * @returns {Array} semi-deep clone of given array
+     */
+    public static CloneArrayAndItsItems<T>(array: T[], arrayItemsClass?: any, deepClone: boolean = false): T[] {
+        const cloneArray: T[] = [];
+
+        if (array) {
+            for (let i: number = 0, len: number = array.length; i < len; i++) {
+                if (deepClone) {
+                    cloneArray.push(ObjectUtils.GetDeepClone(array[i]));
+                } else {
+                    cloneArray.push(ObjectUtils.GetShallowClone(array[i], arrayItemsClass));
+                }
+            }
+        } else {
+            return [];
+        }
+
+        return cloneArray;
+    }
+
+    /**
+     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really
+     * removes the element using splice().
+     *
+     * @param {number} index
+     * @param {any[]} array in-out
+     * @returns {boolean} True if and only if the element on given index is succesfully removed from given array.
+     */
+    public static RemoveElementAtIndex(index: number, array: any[]): boolean {
+        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {
+            return false;
+        }
+
+        if (index in array) {
+            array.splice(index, 1);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really removes the
+     * element using splice(). Also works on associative arrays.
+     *
+     * @param {T} element The element to remove.
+     * @param {T[]} array The array to remove the element from.
+     * @returns {boolean} True iff given element was truly successfully removed from given array.
+     */
+    public static RemoveElement<T>(element: T, array: T[]): boolean {
+        if (!Array.isArray(array)) {
+            return false;
+        }
+
+        const index: number = array.indexOf(element);
+        return ArrayUtils.RemoveElementAtIndex(index, array);
+    }
+
+    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.
+    public static IsArrayWithElements<T>(arrayToCheck: T[], classItemsMustBeInstanceOf?: any): boolean {
+        if (isNill(arrayToCheck)) {
+            return false;
+        }
+
+        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {
+            if (classItemsMustBeInstanceOf) {
+                return arrayToCheck[0] instanceof classItemsMustBeInstanceOf;
+            } else {
+                return true;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.
+    public static RemoveElementsByFilter(array: any[], filterFunction: (item: any) => boolean): boolean {
+        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {
+            return false;
+        }
+
+        let atLeastOneRemoved: boolean = false;
+
+        const len: number = array.length;
+        for (let i: number = len - 1; i >= 0; i--) {
+            const item: any = array[i];
+            if (filterFunction.call(this, item) === true) {
+                array.splice(i, 1);
+                atLeastOneRemoved = true;
+            }
+        }
+
+        return atLeastOneRemoved;
+    }
+
+    public static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean {
+        if (!Array.isArray(array) || isNill(toIndex)) {
+            return false;
+        }
+
+        const fromIndex: number = array.indexOf(element);
+        const toIndexCorrected: number = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);
+        if (fromIndex === -1 || array[toIndexCorrected] === element) {
+            // element did not exist in given array, or already existed on given toIndex
+            return false;
+        }
+        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);
+        return true;
+    }
+
+    // PRE: elements exists in given array. POST: given elementToPlace has a lower index than given afterThisElement. Array is in-out manipulated.
+    public static PlaceElementAfterOther(array: any[], elementToPlace: any, afterThisElement: any): void {
+        if (array) {
+            const afterThisElIdx: number = array.indexOf(afterThisElement);
+            const elToPlaceIdx: number = array.indexOf(elementToPlace);
+            if (afterThisElIdx >= elToPlaceIdx) {
+                ArrayUtils.MoveElement(elementToPlace, afterThisElIdx + 1, array);
+            }
+        }
+    }
+}

package/projects/sharedcomponents/src/lib/utils/calendar.utils.ts

@@ -0,0 +1,75 @@
+import {DateUtils} from "./date-utils";
+import {Weekday} from "../model/weekday.model";
+import {Inject, LOCALE_ID} from "@angular/core";
+import {LanguageCode} from "../enum/language-code.enum";
+import {Week} from "../model/week.model";
+
+export class CalendarUtils {
+    public static Locale: LanguageCode;
+
+    public static Now: Date = new Date();
+
+    constructor(
+        @Inject(LOCALE_ID) private readonly _locale: LanguageCode
+    ) {
+        CalendarUtils.Locale = _locale;
+    }
+
+    public static GetCurrentYear(): number {
+        return this.Now.getFullYear();
+    }
+
+    public static GetCurrentMonth(): number {
+        return this.Now.getUTCMonth() + 1;
+    }
+
+    public static GetDayHours(day: Date): Date[] {
+        const datesByTheHour: Date[] = [];
+        if (day) {
+            let newDate: Date = new Date(day);
+            newDate.setHours(0, 0, 0, 0);
+            datesByTheHour.push(newDate);
+            for (let i: number = 0; i < 23; i++) {
+                newDate = new Date(newDate);
+                newDate.setHours(newDate.getHours() + 1);
+                datesByTheHour.push(newDate);
+            }
+        }
+        return datesByTheHour;
+    }
+
+    public static GetDaysOfWeek(date: Date): Week {
+        let day: Date = DateUtils.GetFirstDayOfWeek(date);
+        const daysOfWeek: Weekday[] = [];
+        let options: any;
+        let month: number;
+        for (let i: number = 0; i < 7; i++) {
+            const dayPerWeek: Weekday = new Weekday();
+            const dayHours: Date[] = CalendarUtils.GetDayHours(day);
+            dayPerWeek.newMonth = day.getMonth() !== month;
+            dayPerWeek.weekdaySelected = day.getDay() === date.getDay();
+            dayPerWeek.weekdayDay = day.getDate();
+            options = { weekday: "short" };
+            dayPerWeek.weekdayShort = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { weekday: "long" };
+            dayPerWeek.weekdayLong = day.toLocaleDateString(CalendarUtils.Locale, options);
+
+            options = { month: "short" };
+            dayPerWeek.weekdayMonthShort = day.toLocaleDateString(CalendarUtils.Locale, options);
+            options = { month: "long" };
+            dayPerWeek.weekdayMonthLong = day.toLocaleDateString(CalendarUtils.Locale, options);
+            dayPerWeek.weekdayYear = day.getFullYear();
+
+            dayPerWeek.date = new Date(day);
+            dayPerWeek.datesByTheHour = dayHours;
+            daysOfWeek.push(dayPerWeek);
+            month = day.getMonth();
+            day = new Date(day);
+            day.setDate(day.getDate() + 1);
+        }
+        const week: Week = new Week();
+        week.weekDays = daysOfWeek;
+        return week;
+    }
+
+}

package/projects/sharedcomponents/src/lib/utils/date-utils.ts

@@ -0,0 +1,302 @@
+import {Month} from "../enum/month.enum";
+import {ALL_MONTHS} from "../model/constant/all-months";
+import {notNill} from "./function/not-nill.function";
+import * as moment from "moment";
+import {Moment} from "moment";
+import {DatePipe} from "@angular/common";
+import {DateRange} from "../model/date-range";
+
+Date.prototype.toJSON = function() {
+    return moment(this).format('YYYY-MM-DD[T]HH:mm:ss');
+}
+
+// static utility function holder related to dates
+export class DateUtils {
+    public static readonly BACKEND_DATE_FORMAT: string = 'YYYY-MM-DD[T]HH:mm:ss';
+    public static datePipe: DatePipe;
+
+    public static NowAsString(): string {
+        return DateUtils.ParseDate(new Date(), DateUtils.BACKEND_DATE_FORMAT);
+    }
+
+    public static ParseDate(date: Date, format: string = "d-m-y"): string {
+        if (!date) {
+            return "";
+        }
+
+        const day: string = ("0" + date.getDate()).slice(-2);
+        const month: string = ("0" + (date.getMonth() + 1)).slice(-2);
+        const year: string = date.getFullYear() + "";
+
+        const formatParts: string[] = format.split("-");
+        const dateParts: string[] = [];
+
+
+        for (let i: number = 0, l: number = formatParts.length; i < l; i++) {
+            switch (formatParts[i]) {
+                case "d" :
+                case "DD" :
+                    dateParts.push(day);
+                    break;
+                case "m" :
+                case "MM" :
+                    dateParts.push(month);
+                    break;
+                case "y" :
+                case "YYYY" :
+                    dateParts.push(year);
+                    break;
+                default:
+                    break;
+            }
+        }
+        return dateParts.join("-");
+    }
+
+    public static GetWeekNumber(date: Date): number {
+        date = new Date(date.getTime());
+        date.setHours(0, 0, 0, 0);
+        date.setDate(date.getDate() + 4 - (date.getDay() || 7));
+        return Math.ceil((((date.getTime() - new Date(date.getFullYear(), 0, 1).getTime()) / 8.64e7) + 1) / 7);
+    }
+
+    // Returns the number of days from now, for the given date in the future. Returns negative days if given date is in the past from now.
+    public static GetDaysFromNow(date: Date): number {
+        return DateUtils.GetDayDifference(new Date(Date.now()), date);
+    }
+
+    public static StringAsDate(str: string, format: string = DateUtils.BACKEND_DATE_FORMAT): Date {
+        if (notNill(str)) {
+            if (!isNaN(Number(str))) {
+                return new Date(str);
+            } else {
+                const time: any = moment(str, format, true);
+                return time.isValid() ? new Date(time) : undefined;
+            }
+        } else {
+            return undefined;
+        }
+    }
+
+    public static MomentToDate(time: Moment): Date {
+        if (!time || !time.isValid()) {
+            return undefined;
+        }
+
+        const d: Date = new Date(time.format(DateUtils.BACKEND_DATE_FORMAT));
+        d.setHours(time.hours());
+        d.setMinutes(time.minutes());
+        d.setSeconds(time.seconds());
+        return d;
+    }
+
+    public static GetCurrentMonth(): Month {
+        return ALL_MONTHS[new Date().getMonth()];
+    }
+
+    // @returns e.g. ["FEBRUARI", "MARCH", ..] if it's Februari today, otherwise e.g. ["APRIL", "MAY", ...] if it's April today
+    public static Get12MonthsArrayWithFirstMonthIsCurrentMonth(): Month[] {
+        const answer: Month[] = [];
+
+        let monthNrToAdd: number = new Date().getMonth();
+        for (let i: number = 0; i < 12; i++) {
+            answer.push(ALL_MONTHS[monthNrToAdd]);
+            monthNrToAdd = (monthNrToAdd + 1) % ALL_MONTHS.length;
+        }
+
+        return answer;
+    }
+
+    public static GetFirstDayOfWeek(date: Date): Date {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        let firstDay: Date;
+        const dayOfWeek: number = date.getDay() || 7;
+        if (dayOfWeek === 1) {
+            firstDay = new Date(date);
+        } else {
+            firstDay = new Date(date);
+            firstDay.setHours(-24 * (dayOfWeek - 1));
+        }
+        return firstDay;
+    }
+
+    public static GetLastDayOfWeek(date: Date): Date {
+        const firstDayOfWeek: Date = DateUtils.GetFirstDayOfWeek(date);
+        const lastDayOfWeek: Date = new Date(firstDayOfWeek);
+        lastDayOfWeek.setDate(firstDayOfWeek.getDate() + 6);
+        return lastDayOfWeek;
+    }
+
+    public static GetFirstDayOfMonth(date: Date): Date {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        const year: number = date.getFullYear();
+        const month: number = date.getMonth();
+        return new Date(year, month, 1);
+    }
+
+    public static GetLastDayOfMonth(date: Date): Date {
+        if (!DateUtils._ValidDate(date)) {
+            return null;
+        }
+        const year: number = date.getFullYear();
+        const month: number = date.getMonth();
+        return new Date(year, month + 1, 0);
+    }
+
+    public static DatesEqual(date1: Date, date2: Date): boolean {
+        let result: boolean = false;
+        if (DateUtils._ValidDate(date1) && DateUtils._ValidDate(date2)) {
+            result =
+                date1.getDate() === date2.getDate() &&
+                date1.getMonth() === date2.getMonth() &&
+                date1.getFullYear() === date2.getFullYear();
+        }
+        return result;
+    }
+
+    public static DateRangeEqual(dates1: DateRange, dates2: DateRange): boolean {
+        return (this.DatesEqual(dates1.startDate, dates2.startDate) &&
+            this.DatesEqual(dates1.endDate, dates2.endDate));
+    }
+
+    public static AddMinutes(date: Date, minutes: number): Date {
+        return new Date(date.getTime() + (minutes * 60000));
+    }
+
+    public static AddDays(date: Date, days: number): Date {
+        const result: Date = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+
+    public static AddMonths(date: Date, months: number): Date {
+        const result: Date = new Date(date);
+        result.setMonth(result.getMonth() + months);
+        return result;
+    }
+
+    public static DetermineDSTBreakpoints(): { start: string, end: string } {
+        const endOfYear: Date = new Date(new Date().getFullYear(), 11, 1);
+        let checkDate: Date = new Date(new Date().getFullYear(), 0, 1);
+        let offset: number = checkDate.getTimezoneOffset();
+
+        const periodStart: Date = new Date();
+        let periodStartSet: boolean = false;
+        const periodEnd: Date = new Date();
+        let periodEndSet: boolean = false;
+        while (checkDate.getTime() < endOfYear.getTime()) {
+            checkDate = this.AddMinutes(checkDate, 60);
+            if (offset < checkDate.getTimezoneOffset()) {
+                periodEnd.setTime(checkDate.getTime());
+                periodEndSet = true;
+            } else if (offset > checkDate.getTimezoneOffset()) {
+                periodStart.setTime(checkDate.getTime());
+                periodStartSet = true;
+            }
+            offset = checkDate.getTimezoneOffset();
+            if (periodStartSet && periodEndSet) {
+                break;
+            }
+        }
+
+        if (periodStartSet && periodEndSet) {
+            return {
+                start: this._DateToTimeStringWithDateFormat(periodStart),
+                end: this._DateToTimeStringWithDateFormat(periodEnd)
+            };
+        } else {
+            return {start: undefined, end: undefined}; // important otherwise we return new Date() for both
+        }
+    }
+
+    private static _ValidDate(date: Date): boolean {
+        return date !== null && date !== undefined;
+    }
+
+    /**
+     * Returns the difference between the two given days as the number of days, in float precision (date to - date from).
+     * Returns negative values of the 'from' date is later than in time than the 'to' date.
+     */
+    public static GetDayDifference(from: Date, to: Date): number {
+        if (!from || !to) {
+            return NaN;
+        }
+        return ((to.getTime() - from.getTime()) / 1000 / 60 / 60 / 24);
+    }
+
+    public static IsSameDay(dateOne: Date, dateTwo: Date): boolean {
+        return (dateOne && dateTwo &&
+            dateOne.getDate() === dateTwo.getDate()
+            && dateOne.getMonth() === dateTwo.getMonth()
+            && dateOne.getFullYear() === dateTwo.getFullYear());
+    }
+
+    public static IsInBetween(date: Date, startDate: Date, endDate: Date, withTime: boolean = true): boolean {
+        if (startDate && endDate) {
+            if (withTime) {
+                return (date > startDate && date < endDate);
+            } else {
+                const dateWithoutTime: number = new Date(date).setHours(0, 0, 0, 0),
+                    dateFromWithoutTime: number = new Date(startDate).setHours(0, 0, 0, 0),
+                    dateToWithoutTime: number = new Date(endDate).setHours(0, 0, 0, 0);
+                return dateWithoutTime >= dateFromWithoutTime && dateWithoutTime <= dateToWithoutTime;
+            }
+        }
+    }
+
+    public static IsMonday(date: Date): boolean {
+        return date.getDay() === 1;
+    }
+
+    public static IsSunday(date: Date): boolean {
+        return date.getDay() === 0;
+    }
+
+    public static IsToday(date: Date): boolean {
+        const today: Date = new Date();
+        return DateUtils.IsSameDay(today, date);
+    }
+
+    // Returns date format like it would when using a pipe in the templete, ie: "1 okt. 2020"
+    public static ParseDateInShortDateFormat(date: Date, locale: string): string {
+        this.datePipe = new DatePipe(locale);
+        const parsedDate: string = this.datePipe.transform(date);
+        return parsedDate;
+    }
+
+    // Transforms a string that is formatted like "'17-08-2014'<=?<='17-08-2021'" into "'17-08-2014' Untill '17-08-2021'"
+    public static getFormattedDateRangeString(dateRangeString: string, separator: string = " - "): string {
+        let newString: string = dateRangeString;
+        newString = newString.replace("<=?<=", ` ${separator} `);
+        newString = newString.replace(/'/g, "");
+
+        return newString;
+    }
+
+    public static SetDateOrDateRangeObjectHoursZero(date: Date | DateRange): void {
+        if (date instanceof DateRange) {
+            if (date.startDate) {
+                date.startDate.setHours(0, 0, 0);
+            }
+            if (date.endDate) {
+                date.endDate.setHours(0, 0, 0);
+            }
+        } else if (!!date && (date instanceof Date)) {
+            date.setHours(0, 0, 0, 0);
+        }
+    }
+
+    private static _DateToTimeStringWithDateFormat(value: Date, dateFormat: string = "d-m-y"): string {
+        if (!value) {
+            return "";
+        }
+
+        const hours: string = value.getHours() < 10 ? "0" + value.getHours() : "" + value.getHours();
+        const minutes: string = value.getMinutes() < 10 ? "0" + value.getMinutes() : "" + value.getMinutes();
+        return this.ParseDate(value, dateFormat) + " " + [hours, minutes].join(":");
+    }
+}

package/projects/sharedcomponents/src/lib/utils/function/not-nill.function.ts

@@ -0,0 +1,4 @@
+// @returns true iff given value does not equals null and does not equal undefined
+export function notNill(value: any): boolean {
+    return value !== null && value !== undefined;
+}

package/projects/sharedcomponents/src/lib/utils/is-nill.function.ts

@@ -0,0 +1,4 @@
+// @returns true iff given value equals null or equals undefined
+export function isNill(value: any): boolean {
+    return value === null || value === undefined;
+}

package/projects/sharedcomponents/src/lib/utils/string-utils.ts

@@ -0,0 +1,67 @@
+// Static utility functions holder related to strings.
+export class StringUtils {
+
+  /**
+   * Returns a new string where given placeholder in given source string are replaced by given replacement texts.
+   *
+   * Example usage:
+   *
+   * source = "ABCDABCD"
+   * placeholder = "BC"
+   * replacementTexts = "Z", "Z" (REST arguments)
+   * OUTPUT = "AZDAZD"
+   *
+   * @param {string} source
+   * @param {string} placeholder
+   * @param {string} replacementTexts If only one is given, this function replaces all placeholders with that single replacementText.
+   * If more are given, placeholders without a corresponding replacementText will remain their original placeholder characters.
+   */
+  public static ReplaceOccurrencesIn(source: string, placeholder: string, ...replacementTexts: string[]): string {
+    // parameter guards
+    if (!(source)) {
+      return undefined;
+    }
+    if (!placeholder || replacementTexts.length === 0) {
+      return source;
+    }
+    let outString: string = source;
+    // one replacementText means replace for all
+    if (replacementTexts.length === 1) {
+      // "g" is the g flag to replace globally
+      outString = outString.replace(placeholder, replacementTexts[0]);
+    } else {
+      // replace occurence i by replacementTexts[i], one at a time in loop (there might be a faster way..)
+      for (let i: number = 0, len: number = replacementTexts.length; i < len; i++) {
+        outString = outString.replace(placeholder, replacementTexts[i]);
+      }
+    }
+    return outString;
+  }
+
+  // Returns the given argument as a string. Returns given defaultValue if conversion of argument to string was impossible.
+  public static ParseString(arg: any, defaultValue: string = ""): string {
+    if (!StringUtils.IsString(arg)) {
+      if (arg && typeof arg.toString === "function") {
+        arg = arg.toString();
+      } else {
+        arg = defaultValue;
+      }
+    }
+    return arg;
+  }
+
+  public static IsString(str: any): boolean {
+    return typeof str === 'string';
+  }
+
+  // Returns whether given str is a string and has a length > 0.
+  public static IsStringWithLength(str: string): boolean {
+    return str && StringUtils.IsString(str) && str.length > 0;
+  }
+
+  // Returns given string, escaped for use as string literal in regular expressions.
+  private static _escapeRegExp(str: string): string {
+    return str;// .replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^$\|]/g, "\\$&");
+  }
+
+}

package/{public-api.d.ts → projects/sharedcomponents/src/public-api.ts}

@@ -1,3 +1,7 @@
+/*
+ * Public API Surface of sharedcomponents
+ */
+
 export * from './lib/components/docsign/docsign.component';
 export * from './lib/components/docsign/docsign.module';
 export * from './lib/components/stock/stock.component';
@@ -15,3 +19,4 @@ export * from './lib/components/linear-gauge/co-linear-gauge.module';
 export * from './lib/components/statusbar/statusbar.component';
 export * from './lib/components/statusbar/statusbar.module';
 export * from './lib/service/shared.service';
+