ngx-sfc-common 0.0.1

package/esm2020/lib/utils/common.utils.mjs

@@ -0,0 +1,86 @@
+import { Observable } from 'rxjs';
+/**
+ * Return true if value defined
+ * @param value Value to check
+ * @returns True if value is not null and defined
+ */
+export function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+/**
+ * Return true if value is object
+ * @param value Value to check
+ * @returns True if value is object
+ */
+export function isObject(value) {
+    return (isDefined(value) && typeof value === 'object' && !Array.isArray(value));
+}
+/**
+ * Return true if data is observable
+ * @param data Object to check
+ * @returns True if data is observable
+ */
+export function isAsyncData(data) {
+    return data instanceof Observable;
+}
+/**
+ * Return extended object with new property
+ * @param obj Object to extend by property
+ * @param property New property name
+ * @param value Value for new property
+ * @returns Extended object with new property
+ */
+export function addPropertyToObject(obj, property, value = null) {
+    if (!isDefined(property) && !obj.hasOwnProperty(property)) {
+        let newObj = {};
+        newObj[property] = value;
+        obj = { ...obj, ...newObj };
+    }
+    return obj;
+}
+/**
+ * Remove property from object
+ * @param obj Object for removing property
+ * @param property Property name to remove
+ */
+export function removePropertyFromObject(obj, property) {
+    if (obj.hasOwnProperty(property)) {
+        delete obj[property];
+    }
+}
+/**
+  * Deep merge object with others
+  * @param target Object to merge
+  * @param sources
+  */
+/**
+ * Deep merge object with others
+ * @param target  Object to merge
+ * @param sources Objects to be merged with target
+ * @returns Merged object
+ */
+export function mergeDeep(target, ...sources) {
+    if (!isDefined(sources))
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}
+/**
+ * Get type's property name safety
+ * @param name KeyOf property
+ * @returns Type's property name
+ */
+export const nameof = (name) => name;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,208 @@
+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) {
+    date.setMinutes(minute);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes());
+}
+/**
+ * Set hours for date
+ * @param date Date value
+ * @param hour Hour value
+ * @returns Date with hour value
+ */
+export function setHours(date, hour) {
+    date.setHours(hour);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes());
+}
+/**
+ * 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) {
+    date.setFullYear(year);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes());
+}
+/**
+ * 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) {
+    date1.setHours(0, 0, 0, 0);
+    date2.setHours(0, 0, 0, 0);
+    return date1.getTime() === date2.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":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;GAKG;AACF,MAAM,UAAU,UAAU,CAAC,IAAU,EAAE,MAAc;IAClD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACxB,OAAO,IAAI,IAAI,CACX,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,EACd,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,UAAU,EAAE,CACpB,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAU,EAAE,IAAY;IAC7C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACpB,OAAO,IAAI,IAAI,CACX,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,EACd,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,UAAU,EAAE,CACpB,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,IAAU,EAAE,SAAiB;IAChD,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAC5B,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,IAAU,EAAE,IAAY;IAC5C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,IAAI,IAAI,CACX,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,OAAO,EAAE,EACd,IAAI,CAAC,QAAQ,EAAE,EACf,IAAI,CAAC,UAAU,EAAE,CACpB,CAAC;AACN,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,IAAU;IACnC,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAA;IACvC,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAU;IACvC,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;IACxC,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAU;IAClC,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7C,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,IAAU;IACtC,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7C,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAU;IACzC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,EAAE;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,EAC3B,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC5B,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;KACnC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAU;IACxC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,EAAE;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,EAC3B,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC5B,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;KACvC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAU;IACxC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,EAAE;QACzC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;KAC7C;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAU;IACvC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,EAAE;QACzC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;KAC9C;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gCAAgC,CAAC,IAAY,EAAE,KAAa;IACxE,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,+BAA+B,CAAC,IAAY,EAAE,KAAa;IACvE,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAU;IAC5C,MAAM,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC,EACzC,WAAW,GAAG,iBAAiB,CAAC,IAAI,CAAC,EACrC,IAAI,GAAG,YAAY,CAAC,MAAM,EAAE,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC;IACzD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAW,EAAE,KAAW;IACjD,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3B,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE3B,OAAO,KAAK,CAAC,OAAO,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,KAAW,EAAE,KAAW;IAChD,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;UACjE,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAW,EAAE,KAAW;IACvD,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;WAChE,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,KAAW,EAAE,KAAW;IACpD,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,EAClE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;UACnC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,EAC7D,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;AAClD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAW,EAAE,KAAW;IAC3D,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,EAClE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;WAClC,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,EAC9D,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;AAClD,CAAC","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\n export function setMinutes(date: Date, minute: number): Date {\r\n    date.setMinutes(minute);\r\n    return new Date(\r\n        date.getFullYear(),\r\n        date.getMonth(),\r\n        date.getDate(),\r\n        date.getHours(),\r\n        date.getMinutes()\r\n    );\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    date.setHours(hour);\r\n    return new Date(\r\n        date.getFullYear(),\r\n        date.getMonth(),\r\n        date.getDate(),\r\n        date.getHours(),\r\n        date.getMinutes()\r\n    );\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    date.setFullYear(year);\r\n    return new Date(\r\n        date.getFullYear(),\r\n        date.getMonth(),\r\n        date.getDate(),\r\n        date.getHours(),\r\n        date.getMinutes()\r\n    );\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    date1.setHours(0, 0, 0, 0);\r\n    date2.setHours(0, 0, 0, 0);\r\n\r\n    return date1.getTime() === date2.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,52 @@
+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);
+    }
+    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 (/\.(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 } from './common.utils';
+export { isNullOrEmptyString, contains, trim } from './string.utils';
+export { setMinutes, setHours, setDay, setYear, getNextMonth, getPreviousMonth, getNextYear, getPreviousYear, getFirstDayOfMonth, getLastDayOfMonth, getFirstDayOfYear, getLastDayOfYear, getFirstDayOfMonthByYearAndMonth, getLastDayOfMonthByYearAndMonth, getWeeksNumberInMonth, isEqualDates, isDateGreat, isDateGreatOrEqual, isDateTimeGreat, isDateTimeGreatOrEqual } from './date-time.utils';
+export { parseFileSize, getFileExtension, readAsDataURL, isImage } from './file.utils';
+export { getCssLikeValue, getValueFromCssLikeValue, addClasses, removeClasses } from './ui.utils';
+export { any, hasItem, hasItemBy, hasObjectItem, firstOrDefault, firstItem, lastItem, all, where, skip, sortBy, sortByPath, distinct, sum, max, remove, addItem, removeItem, updateItem, getCollectionOrEmpty } 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,39 @@
+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);
+}
+/**
+ * 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));
+    }
+}
+//# 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,11 @@
+/*
+ * 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/components';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1zZmMtY29tbW9uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5neC1zZmMtY29tbW9uXHJcbiAqL1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmd4LXNmYy1jb21tb24ubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29uc3RhbnRzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZW51bXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi91dGlscyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMnO1xyXG4iXX0=