ngx-sfc-common 0.0.0-watch

package/esm2020/lib/utils/date-time.utils.mjs

@@ -0,0 +1,265 @@
+import { DateTimeConstants } from "../constants";
+import { isDefined } from "./common.utils";
+/**
+ * Set minutes for date
+ * @param date Date value
+ * @param minute Minute value
+ * @returns Date with minute value
+ */
+export function setMinutes(date, minute) {
+    const result = new Date(date);
+    result.setMinutes(minute);
+    return result;
+}
+/**
+ * Set hours for date
+ * @param date Date value
+ * @param hour Hour value
+ * @returns Date with hour value
+ */
+export function setHours(date, hour) {
+    const result = new Date(date);
+    result.setHours(hour);
+    return result;
+}
+/**
+ * Set day for date value
+ * @param date Date value
+ * @param dayNumber Day number
+ * @returns Date with day number
+ */
+export function setDay(date, dayNumber) {
+    const nextDate = new Date(date);
+    nextDate.setDate(dayNumber);
+    return nextDate;
+}
+/**
+ * Set year for date
+ * @param date Date value
+ * @param year Year value
+ * @returns Date with year value
+ */
+export function setYear(date, year) {
+    const result = new Date(date);
+    result.setFullYear(year);
+    return result;
+}
+/**
+ * Set seconds for date
+ * @param date Date value
+ * @param value Seconds value
+ * @returns Date with minute value
+ */
+export function setSeconds(date, value) {
+    const result = new Date(date);
+    result.setSeconds(value);
+    return result;
+}
+/**
+ * Set milliseconds for date
+ * @param date Date value
+ * @param value Milliseconds value
+ * @returns Date with minute value
+ */
+export function setMilliseconds(date, value) {
+    const result = new Date(date);
+    result.setMilliseconds(value);
+    return result;
+}
+/**
+ * Set 0 for seconds and milliseconds of date
+ * @param date Date value
+ * @returns Date with minute value
+ */
+export function setDefaultSecondsAndMiliseconds(date) {
+    const result = new Date(date);
+    result.setSeconds(0);
+    result.setMilliseconds(0);
+    return result;
+}
+/**
+ * Get next date
+ * @param date Date value
+ * @returns Next date
+ */
+export function getNextDate(date) {
+    const nextDate = new Date(date);
+    nextDate.setDate(date.getDate() + 1);
+    return nextDate;
+}
+/**
+ * Get next month as date
+ * @param date Date value
+ * @returns Next month as date
+ */
+export function getNextMonth(date) {
+    const nextMonth = new Date(date);
+    nextMonth.setMonth(date.getMonth() + 1);
+    return nextMonth;
+}
+/**
+ * Get previous month as date
+ * @param date Date value
+ * @returns Previous month as date
+ */
+export function getPreviousMonth(date) {
+    const prevMonth = new Date(date);
+    prevMonth.setMonth(date.getMonth() - 1);
+    return prevMonth;
+}
+/**
+ * Get next year as date
+ * @param date Date value
+ * @returns Next year as date
+ */
+export function getNextYear(date) {
+    const nextYear = new Date(date);
+    nextYear.setFullYear(date.getFullYear() + 1);
+    return nextYear;
+}
+/**
+ * Get previous year as date
+ * @param date Date value
+ * @returns Previous year as date
+ */
+export function getPreviousYear(date) {
+    const prevYear = new Date(date);
+    prevYear.setFullYear(date.getFullYear() - 1);
+    return prevYear;
+}
+/**
+ * Return first day of month as date from date value
+ * @param date Date value
+ * @returns First day of month as date
+ */
+export function getFirstDayOfMonth(date) {
+    if (isDefined(date) && date instanceof Date) {
+        const year = date.getFullYear(), month = date.getMonth();
+        return new Date(year, month, 1);
+    }
+    return date;
+}
+/**
+ * Return last day of month as date from date value
+ * @param date Date value
+ * @returns Last day of month as date
+ */
+export function getLastDayOfMonth(date) {
+    if (isDefined(date) && date instanceof Date) {
+        const year = date.getFullYear(), month = date.getMonth();
+        return new Date(year, month + 1, 0);
+    }
+    return date;
+}
+/**
+ * Return first day of year as date from date value
+ * @param date Date value
+ * @returns First day of year as date
+ */
+export function getFirstDayOfYear(date) {
+    if (isDefined(date) && date instanceof Date) {
+        return new Date(date.getFullYear(), 0, 1);
+    }
+    return date;
+}
+/**
+ * Return last day of year as date from date value
+ * @param date Date value
+ * @returns Last day of year as date
+ */
+export function getLastDayOfYear(date) {
+    if (isDefined(date) && date instanceof Date) {
+        return new Date(date.getFullYear(), 12, 0);
+    }
+    return date;
+}
+/**
+ * Return first day of month as date
+ * @param year Year value
+ * @param month Month value
+ * @returns First day of month
+ */
+export function getFirstDayOfMonthByYearAndMonth(year, month) {
+    return new Date(year, month, 1);
+}
+/**
+ * Return last day of month as date
+ * @param year Year value
+ * @param month Month value
+ * @returns Last day of month
+ */
+export function getLastDayOfMonthByYearAndMonth(year, month) {
+    return new Date(year, month + 1, 0);
+}
+/**
+ * Return week number in month from date value
+ * @param date Date value
+ * @returns Week number
+ */
+export function getWeeksNumberInMonth(date) {
+    const firstOfMonth = getFirstDayOfMonth(date), lastOfMonth = getLastDayOfMonth(date), used = firstOfMonth.getDay() + lastOfMonth.getDate();
+    return Math.ceil(used / DateTimeConstants.DAYS_IN_WEEK);
+}
+/**
+ * Return true if first and second date are equal
+ * @param date1 First date value
+ * @param date2 Second date value
+ * @returns True if first and second date are equal
+ */
+export function isEqualDates(date1, date2) {
+    const date1Value = new Date(date1), date2Value = new Date(date2);
+    date1Value.setHours(0, 0, 0, 0);
+    date2Value.setHours(0, 0, 0, 0);
+    return date1Value.getTime() === date2Value.getTime();
+}
+/**
+ * Return true if first and second datetime are equal
+ * @param date1 First datetime value
+ * @param date2 Second datetime value
+ * @returns True if first and second datetime are equal
+ */
+export function isEqualDateTimes(date1, date2) {
+    const date1Value = new Date(date1), date2Value = new Date(date2);
+    return date1Value.getTime() === date2Value.getTime();
+}
+/**
+ * Return true if first date greater than second date
+ * @param date1 First date value
+ * @param date2 Second date value
+ * @returns True if first date greater than second date
+ */
+export function isDateGreat(date1, date2) {
+    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate())
+        > new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());
+}
+/**
+ * Return true if first date greater or equal to second date
+ * @param date1 First date value
+ * @param date2 Second date value
+ * @returns True if first date greater or equal to second date
+ */
+export function isDateGreatOrEqual(date1, date2) {
+    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate())
+        >= new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());
+}
+/**
+ * Return true if first date time greater than second date time
+ * @param date1 First date time value
+ * @param date2 Second date time value
+ * @returns True if first date time greater than second date time
+ */
+export function isDateTimeGreat(date1, date2) {
+    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate(), date1.getHours(), date1.getMinutes())
+        > new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(), date2.getHours(), date2.getMinutes());
+}
+/**
+ * Return true if first date time greater or equal to second date time
+ * @param date1 First date time value
+ * @param date2 Second date time value
+ * @returns True if first date time greater or equal to second date time
+ */
+export function isDateTimeGreatOrEqual(date1, date2) {
+    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate(), date1.getHours(), date1.getMinutes())
+        >= new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(), date2.getHours(), date2.getMinutes());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time.utils.js","sourceRoot":"","sources":["../../../../../projects/ngx-sfc-common/src/lib/utils/date-time.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateTimeConstants } from \"../constants\";\r\nimport { isDefined } from \"./common.utils\";\r\n\r\n/**\r\n * Set minutes for date\r\n * @param date Date value\r\n * @param minute Minute value\r\n * @returns Date with minute value\r\n */\r\nexport function setMinutes(date: Date, minute: number): Date {\r\n    const result = new Date(date);\r\n    result.setMinutes(minute);\r\n    return result;\r\n}\r\n\r\n/**\r\n * Set hours for date\r\n * @param date Date value\r\n * @param hour Hour value\r\n * @returns Date with hour value\r\n */\r\nexport function setHours(date: Date, hour: number): Date {\r\n    const result = new Date(date);\r\n    result.setHours(hour);\r\n    return result;\r\n}\r\n\r\n/**\r\n * Set day for date value\r\n * @param date Date value\r\n * @param dayNumber Day number \r\n * @returns Date with day number\r\n */\r\nexport function setDay(date: Date, dayNumber: number): Date {\r\n    const nextDate = new Date(date);\r\n    nextDate.setDate(dayNumber);\r\n    return nextDate;\r\n}\r\n\r\n/**\r\n * Set year for date\r\n * @param date Date value\r\n * @param year Year value\r\n * @returns Date with year value\r\n */\r\nexport function setYear(date: Date, year: number): Date {\r\n    const result = new Date(date);\r\n    result.setFullYear(year);\r\n    return result;\r\n}\r\n\r\n/**\r\n * Set seconds for date\r\n * @param date Date value\r\n * @param value Seconds value\r\n * @returns Date with minute value\r\n */\r\nexport function setSeconds(date: Date, value: number): Date {\r\n    const result = new Date(date);\r\n    result.setSeconds(value);\r\n    return result;\r\n}\r\n\r\n/**\r\n * Set milliseconds for date\r\n * @param date Date value\r\n * @param value Milliseconds value\r\n * @returns Date with minute value\r\n */\r\nexport function setMilliseconds(date: Date, value: number): Date {\r\n    const result = new Date(date);\r\n    result.setMilliseconds(value);\r\n    return result;\r\n}\r\n\r\n/**\r\n * Set 0 for seconds and milliseconds of date\r\n * @param date Date value\r\n * @returns Date with minute value\r\n */\r\nexport function setDefaultSecondsAndMiliseconds(date: Date): Date {\r\n    const result = new Date(date);\r\n    result.setSeconds(0);\r\n    result.setMilliseconds(0);\r\n    return result;\r\n}\r\n\r\n/**\r\n * Get next date\r\n * @param date Date value\r\n * @returns Next date\r\n */\r\nexport function getNextDate(date: Date): Date {\r\n    const nextDate = new Date(date);\r\n    nextDate.setDate(date.getDate() + 1)\r\n    return nextDate;\r\n}\r\n\r\n/**\r\n * Get next month as date\r\n * @param date Date value\r\n * @returns Next month as date\r\n */\r\nexport function getNextMonth(date: Date): Date {\r\n    const nextMonth = new Date(date);\r\n    nextMonth.setMonth(date.getMonth() + 1)\r\n    return nextMonth;\r\n}\r\n\r\n/**\r\n * Get previous month as date\r\n * @param date Date value\r\n * @returns Previous month as date\r\n */\r\nexport function getPreviousMonth(date: Date): Date {\r\n    const prevMonth = new Date(date);\r\n    prevMonth.setMonth(date.getMonth() - 1);\r\n    return prevMonth;\r\n}\r\n\r\n/**\r\n * Get next year as date\r\n * @param date Date value\r\n * @returns Next year as date\r\n */\r\nexport function getNextYear(date: Date): Date {\r\n    const nextYear = new Date(date);\r\n    nextYear.setFullYear(date.getFullYear() + 1);\r\n    return nextYear;\r\n}\r\n\r\n/**\r\n * Get previous year as date\r\n * @param date Date value\r\n * @returns Previous year as date\r\n */\r\nexport function getPreviousYear(date: Date): Date {\r\n    const prevYear = new Date(date);\r\n    prevYear.setFullYear(date.getFullYear() - 1);\r\n    return prevYear;\r\n}\r\n\r\n/**\r\n * Return first day of month as date from date value\r\n * @param date Date value\r\n * @returns First day of month as date\r\n */\r\nexport function getFirstDayOfMonth(date: Date): Date {\r\n    if (isDefined(date) && date instanceof Date) {\r\n        const year = date.getFullYear(),\r\n            month = date.getMonth();\r\n        return new Date(year, month, 1);\r\n    }\r\n\r\n    return date;\r\n}\r\n\r\n/**\r\n * Return last day of month as date from date value\r\n * @param date Date value\r\n * @returns Last day of month as date\r\n */\r\nexport function getLastDayOfMonth(date: Date): Date {\r\n    if (isDefined(date) && date instanceof Date) {\r\n        const year = date.getFullYear(),\r\n            month = date.getMonth();\r\n        return new Date(year, month + 1, 0);\r\n    }\r\n\r\n    return date;\r\n}\r\n\r\n/**\r\n * Return first day of year as date from date value\r\n * @param date Date value\r\n * @returns First day of year as date\r\n */\r\nexport function getFirstDayOfYear(date: Date): Date {\r\n    if (isDefined(date) && date instanceof Date) {\r\n        return new Date(date.getFullYear(), 0, 1);\r\n    }\r\n\r\n    return date;\r\n}\r\n\r\n/**\r\n * Return last day of year as date from date value\r\n * @param date Date value\r\n * @returns Last day of year as date\r\n */\r\nexport function getLastDayOfYear(date: Date): Date {\r\n    if (isDefined(date) && date instanceof Date) {\r\n        return new Date(date.getFullYear(), 12, 0);\r\n    }\r\n\r\n    return date;\r\n}\r\n\r\n/**\r\n * Return first day of month as date\r\n * @param year Year value\r\n * @param month Month value\r\n * @returns First day of month\r\n */\r\nexport function getFirstDayOfMonthByYearAndMonth(year: number, month: number): Date {\r\n    return new Date(year, month, 1);\r\n}\r\n\r\n/**\r\n * Return last day of month as date\r\n * @param year Year value\r\n * @param month Month value\r\n * @returns Last day of month\r\n */\r\nexport function getLastDayOfMonthByYearAndMonth(year: number, month: number): Date {\r\n    return new Date(year, month + 1, 0);\r\n}\r\n\r\n/**\r\n * Return week number in month from date value\r\n * @param date Date value\r\n * @returns Week number\r\n */\r\nexport function getWeeksNumberInMonth(date: Date): number {\r\n    const firstOfMonth = getFirstDayOfMonth(date),\r\n        lastOfMonth = getLastDayOfMonth(date),\r\n        used = firstOfMonth.getDay() + lastOfMonth.getDate();\r\n    return Math.ceil(used / DateTimeConstants.DAYS_IN_WEEK);\r\n}\r\n\r\n/**\r\n * Return true if first and second date are equal\r\n * @param date1 First date value\r\n * @param date2 Second date value\r\n * @returns True if first and second date are equal\r\n */\r\nexport function isEqualDates(date1: Date, date2: Date): boolean {\r\n    const date1Value = new Date(date1),\r\n        date2Value = new Date(date2);\r\n    date1Value.setHours(0, 0, 0, 0);\r\n    date2Value.setHours(0, 0, 0, 0);\r\n\r\n    return date1Value.getTime() === date2Value.getTime();\r\n}\r\n\r\n/**\r\n * Return true if first and second datetime are equal\r\n * @param date1 First datetime value\r\n * @param date2 Second datetime value\r\n * @returns True if first and second datetime are equal\r\n */\r\n export function isEqualDateTimes(date1: Date, date2: Date): boolean {\r\n    const date1Value = new Date(date1),\r\n        date2Value = new Date(date2);\r\n\r\n    return date1Value.getTime() === date2Value.getTime();\r\n}\r\n\r\n/**\r\n * Return true if first date greater than second date\r\n * @param date1 First date value\r\n * @param date2 Second date value\r\n * @returns True if first date greater than second date\r\n */\r\nexport function isDateGreat(date1: Date, date2: Date): boolean {\r\n    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate())\r\n        > new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());\r\n}\r\n\r\n/**\r\n * Return true if first date greater or equal to second date\r\n * @param date1 First date value\r\n * @param date2 Second date value\r\n * @returns True if first date greater or equal to second date\r\n */\r\nexport function isDateGreatOrEqual(date1: Date, date2: Date): boolean {\r\n    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate())\r\n        >= new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());\r\n}\r\n\r\n/**\r\n * Return true if first date time greater than second date time\r\n * @param date1 First date time value\r\n * @param date2 Second date time value\r\n * @returns True if first date time greater than second date time\r\n */\r\nexport function isDateTimeGreat(date1: Date, date2: Date): boolean {\r\n    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate(),\r\n        date1.getHours(), date1.getMinutes())\r\n        > new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(),\r\n            date2.getHours(), date2.getMinutes());\r\n}\r\n\r\n/**\r\n * Return true if first date time greater or equal to second date time\r\n * @param date1 First date time value\r\n * @param date2 Second date time value\r\n * @returns True if first date time greater or equal to second date time\r\n */\r\nexport function isDateTimeGreatOrEqual(date1: Date, date2: Date): boolean {\r\n    return new Date(date1.getFullYear(), date1.getMonth(), date1.getDate(),\r\n        date1.getHours(), date1.getMinutes())\r\n        >= new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(),\r\n            date2.getHours(), date2.getMinutes());\r\n}"]}

package/esm2020/lib/utils/file.utils.mjs

@@ -0,0 +1,53 @@
+import { CommonConstants } from "../constants";
+import { isDefined } from "./common.utils";
+/**
+ * Return parsed file size as string
+ * @param bytes Bytes count
+ * @param decimals Value after dot
+ * @returns Parsed file size
+ */
+export function parseFileSize(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+/**
+ * Return file extension
+ * @param file File value
+ * @returns File extension
+ */
+export function getFileExtension(file) {
+    if (!isDefined(file))
+        return CommonConstants.EMPTY_STRING;
+    if (file.name.indexOf('.') === CommonConstants.NOT_FOUND_INDEX) {
+        return CommonConstants.EMPTY_STRING;
+    }
+    return file.name.split('.').pop();
+}
+/**
+ * Read file as data URL
+ * @param file File value
+ * @param onLoad On load action
+ */
+export function readAsDataURL(file, onLoad) {
+    if (isDefined(file)) {
+        const reader = new FileReader();
+        reader.onload = () => onLoad(reader.result);
+        reader.readAsDataURL(file);
+    }
+    else
+        throw new Error('File utils | Read as data URL function --> File is empty.');
+}
+/**
+ * Return true if file is image
+ * @param file File value
+ * @returns True if file is image
+ */
+export function isImage(file) {
+    return isDefined(file) && (/\.(gif|jpe?g|jpg|tiff|png|webp|bmp)$/i).test(file.name);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/index.mjs

@@ -0,0 +1,7 @@
+export { isDefined, isObject, isAsyncData, addPropertyToObject, removePropertyFromObject, mergeDeep, nameof, isNumeric, isChromeBrowser, isEmail, parseBoolean, isEqual } from './common.utils';
+export { isNullOrEmptyString, contains, trim } from './string.utils';
+export { setMinutes, setHours, setDay, setYear, setSeconds, setMilliseconds, setDefaultSecondsAndMiliseconds, getNextDate, getNextMonth, getPreviousMonth, getNextYear, getPreviousYear, getFirstDayOfMonth, getLastDayOfMonth, getFirstDayOfYear, getLastDayOfYear, getFirstDayOfMonthByYearAndMonth, getLastDayOfMonthByYearAndMonth, getWeeksNumberInMonth, isEqualDates, isEqualDateTimes, isDateGreat, isDateGreatOrEqual, isDateTimeGreat, isDateTimeGreatOrEqual } from './date-time.utils';
+export { parseFileSize, getFileExtension, readAsDataURL, isImage } from './file.utils';
+export { getCssLikeValue, getValueFromCssLikeValue, getCalcValue, getRotateValue, addClasses, removeClasses, rgbToHex, hexToRgb, replaceRgbOpacity } from './ui.utils';
+export { any, hasItem, hasItemBy, hasObjectItem, firstOrDefault, firstItem, lastItem, all, where, skip, sort, sortBy, sortByPath, distinct, sum, max, remove, addItem, removeItem, removeItemBy, updateItemBy, getCollectionOrEmpty, count } from './collections.utils';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/string.utils.mjs

@@ -0,0 +1,31 @@
+import { CommonConstants } from "../constants";
+import { isDefined } from "./common.utils";
+/**
+ * Return true if string has value(not empty string)
+ * @param value String value to check
+ * @returns True if string is not null and defined(not empty string)
+ */
+export function isNullOrEmptyString(value) {
+    return !isDefined(value) || value === CommonConstants.EMPTY_STRING;
+}
+/**
+ * Return true if value contains includeValue
+ * @param value String value to check
+ * @param includeValue Value to check if it include
+ * @returns True if value contains includeValue
+ */
+export function contains(value, includeValue) {
+    return !isNullOrEmptyString(value) && !isNullOrEmptyString(includeValue)
+        ? value.toLowerCase()
+            .includes(includeValue.toLowerCase())
+        : false;
+}
+/**
+ * Return trimed value
+ * @param value Value for trim modification
+ * @returns Trimed value
+ */
+export function trim(value) {
+    return isNullOrEmptyString(value) ? value : value.replace(/\s/g, '');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/ui.utils.mjs

@@ -0,0 +1,90 @@
+import { CommonConstants, UIConstants } from "../constants";
+import { isDefined } from "./common.utils";
+/**
+ * Return CSS like value
+ * @param value Value as number
+ * @returns Value as '1px'
+ */
+export function getCssLikeValue(value, type = UIConstants.CSS_PIXELS) {
+    return value + type;
+}
+/**
+ * Parse CSS like value to number
+ * @param value CSS like value
+ * @returns Number value
+ */
+export function getValueFromCssLikeValue(value, type = UIConstants.CSS_PIXELS) {
+    return +value.replace(type, CommonConstants.EMPTY_STRING);
+}
+/**
+ * Return CCS like calc value
+ * @param value All value (100% by default)
+ * @param part Part value
+ * @returns Calc value
+ */
+export function getCalcValue(part, value = 100) {
+    return `calc(${value}${UIConstants.CSS_PERCENTAGE} / ${part} )`;
+}
+/**
+ * Return CCS like rotate value
+ * @param value value as degrees
+ * @returns Rotate value
+ */
+export function getRotateValue(value) {
+    return `rotate(${value}deg)`;
+}
+/**
+ * Add classes to HTML element
+ * @param element HTML element
+ * @param classNames Array of CSS classes
+ */
+export function addClasses(element, ...classNames) {
+    if (isDefined(element)) {
+        classNames.forEach((className) => element.classList.add(className));
+    }
+}
+/**
+ * Remove classes to HTML element
+ * @param element HTML element
+ * @param classNames Array of CSS classes
+ */
+export function removeClasses(element, ...classNames) {
+    if (isDefined(element)) {
+        classNames.forEach((className) => element.classList.remove(className));
+    }
+}
+/**
+ * Convert RGB color to HEX
+ * @param r Red
+ * @param g Green
+ * @param b Blue
+ * @returns HEX value
+ */
+export function rgbToHex(r, g, b) {
+    return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+}
+/**
+ * Convert HEX to RGB value
+ * @param hex HEX value
+ * @returns RGB value
+ */
+export function hexToRgb(hex) {
+    var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    if (result) {
+        var r = parseInt(result[1], 16);
+        var g = parseInt(result[2], 16);
+        var b = parseInt(result[3], 16);
+        return `rgb(${r}, ${g}, ${b})`;
+    }
+    return null;
+}
+/**
+ * Set opacity for RGB value
+ * @param rgb Rgb value with {opacity} placeholder
+ * @param opacity Opacity value
+ * @returns RGB value with relevant opacity
+ */
+export function replaceRgbOpacity(rgb, opacity) {
+    return rgb.replace(UIConstants.RGB_OPACITY_PLACEHOLDER, opacity.toString());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-sfc-common.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LXNmYy1jb21tb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2ZjLWNvbW1vbi9zcmMvbmd4LXNmYy1jb21tb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/public-api.mjs

@@ -0,0 +1,12 @@
+/*
+ * Public API Surface of ngx-sfc-common
+ */
+export * from './lib/ngx-sfc-common.module';
+export * from './lib/constants';
+export * from './lib/enums';
+export * from './lib/utils';
+export * from './lib/services';
+export * from './lib/directives';
+export * from './lib/pipes';
+export * from './lib/components';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1zZmMtY29tbW9uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5neC1zZmMtY29tbW9uXHJcbiAqL1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmd4LXNmYy1jb21tb24ubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29uc3RhbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZW51bXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi91dGlscyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BpcGVzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cyc7XHJcbiJdfQ==