ngx-sfc-common 0.0.1

package/esm2020/lib/ngx-sfc-common.module.mjs

@@ -0,0 +1,135 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { DOCUMENT_PROVIDERS, WINDOW_PROVIDERS } from './services';
+import { ClickOutsideDirective, ShowHideElementDirective, ThrowElementOnHoverDirective, TemplateReferenceDirective, MouseDownDirective, ComponentSizeDirective } from './directives';
+import { ButtonComponent, TooltipComponent, DelimeterComponent, BounceLoaderComponent, CircleLoaderComponent, ModalComponent, ModalOpenOnClickDirective, DefaultModalHeaderComponent, DefaultModalFooterComponent, HamburgerComponent, DotsComponent, ToggleSwitcherComponent, CheckmarkComponent } from './components';
+import * as i0 from "@angular/core";
+export class NgxSfcCommonModule {
+}
+NgxSfcCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: NgxSfcCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxSfcCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: NgxSfcCommonModule, declarations: [
+        // directives
+        ClickOutsideDirective,
+        ShowHideElementDirective,
+        ThrowElementOnHoverDirective,
+        TemplateReferenceDirective,
+        MouseDownDirective,
+        ComponentSizeDirective,
+        // components
+        ButtonComponent,
+        TooltipComponent,
+        DelimeterComponent,
+        // loaders
+        BounceLoaderComponent,
+        CircleLoaderComponent,
+        // modal
+        ModalComponent,
+        ModalOpenOnClickDirective,
+        DefaultModalHeaderComponent,
+        DefaultModalFooterComponent,
+        // hamburger
+        HamburgerComponent,
+        // dots
+        DotsComponent,
+        //toggle
+        ToggleSwitcherComponent,
+        CheckmarkComponent], imports: [CommonModule,
+        BrowserAnimationsModule], exports: [
+        // directives
+        ClickOutsideDirective,
+        ShowHideElementDirective,
+        ThrowElementOnHoverDirective,
+        TemplateReferenceDirective,
+        MouseDownDirective,
+        ComponentSizeDirective,
+        // components
+        ButtonComponent,
+        TooltipComponent,
+        DelimeterComponent,
+        // loaders
+        BounceLoaderComponent,
+        CircleLoaderComponent,
+        // modal
+        ModalComponent,
+        ModalOpenOnClickDirective,
+        DefaultModalHeaderComponent,
+        DefaultModalFooterComponent,
+        // hamburger
+        HamburgerComponent,
+        // dots
+        DotsComponent,
+        //toggle
+        ToggleSwitcherComponent,
+        CheckmarkComponent] });
+NgxSfcCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: NgxSfcCommonModule, providers: [DOCUMENT_PROVIDERS, WINDOW_PROVIDERS], imports: [[
+            CommonModule,
+            BrowserAnimationsModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: NgxSfcCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        // directives
+                        ClickOutsideDirective,
+                        ShowHideElementDirective,
+                        ThrowElementOnHoverDirective,
+                        TemplateReferenceDirective,
+                        MouseDownDirective,
+                        ComponentSizeDirective,
+                        // components
+                        ButtonComponent,
+                        TooltipComponent,
+                        DelimeterComponent,
+                        // loaders
+                        BounceLoaderComponent,
+                        CircleLoaderComponent,
+                        // modal
+                        ModalComponent,
+                        ModalOpenOnClickDirective,
+                        DefaultModalHeaderComponent,
+                        DefaultModalFooterComponent,
+                        // hamburger
+                        HamburgerComponent,
+                        // dots
+                        DotsComponent,
+                        //toggle
+                        ToggleSwitcherComponent,
+                        CheckmarkComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        BrowserAnimationsModule
+                    ],
+                    exports: [
+                        // directives
+                        ClickOutsideDirective,
+                        ShowHideElementDirective,
+                        ThrowElementOnHoverDirective,
+                        TemplateReferenceDirective,
+                        MouseDownDirective,
+                        ComponentSizeDirective,
+                        // components
+                        ButtonComponent,
+                        TooltipComponent,
+                        DelimeterComponent,
+                        // loaders
+                        BounceLoaderComponent,
+                        CircleLoaderComponent,
+                        // modal
+                        ModalComponent,
+                        ModalOpenOnClickDirective,
+                        DefaultModalHeaderComponent,
+                        DefaultModalFooterComponent,
+                        // hamburger
+                        HamburgerComponent,
+                        // dots
+                        DotsComponent,
+                        //toggle
+                        ToggleSwitcherComponent,
+                        CheckmarkComponent
+                    ],
+                    providers: [DOCUMENT_PROVIDERS, WINDOW_PROVIDERS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/document-ref.service.mjs

@@ -0,0 +1,70 @@
+import { isPlatformBrowser } from '@angular/common';
+import { InjectionToken, PLATFORM_ID, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Create a new injection token for injecting the Document into a component.
+ */
+export const DOCUMENT = new InjectionToken('DocumentToken');
+/**
+ * Define abstract class for obtaining reference to the global Document object.
+ */
+export class DocumentRef {
+    get nativeDocument() {
+        throw new Error('Not implemented.');
+    }
+}
+/**
+ * Define class that implements the abstract class and returns the native Document object.
+ */
+export class BrowserDocumentRef extends DocumentRef {
+    constructor() {
+        super();
+    }
+    /**
+     * @returns Document object
+     */
+    get nativeDocument() {
+        return document;
+    }
+}
+BrowserDocumentRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BrowserDocumentRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BrowserDocumentRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BrowserDocumentRef });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BrowserDocumentRef, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+/**
+ * Create an factory function that returns the native Document object.
+ * @param browserDocumentRef Native Document object
+ * @param platformId id of platform
+ * @returns type of platform of empty object
+ */
+export function documentFactory(browserDocumentRef, platformId) {
+    if (isPlatformBrowser(platformId)) {
+        return browserDocumentRef.nativeDocument;
+    }
+    const doc = {
+        hidden: false,
+        visibilityState: 'visible'
+    };
+    return doc;
+}
+/**
+ * Create a injectable provider for the DocumentRef token that uses the BrowserDocumentRef class.
+ */
+export const browserDocumentProvider = {
+    provide: DocumentRef,
+    useClass: BrowserDocumentRef
+};
+/**
+ * Create an injectable provider that uses the DocumentFactory function for returning the native Document object.
+ */
+export const documentProvider = {
+    provide: DOCUMENT,
+    useFactory: documentFactory,
+    deps: [DocumentRef, PLATFORM_ID]
+};
+/**
+ * Create an array of providers.
+ */
+export const DOCUMENT_PROVIDERS = [browserDocumentProvider, documentProvider];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/index.mjs

@@ -0,0 +1,4 @@
+export * from './document-ref.service';
+export * from './window-ref.service';
+export * from './resize.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2ZjLWNvbW1vbi9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQTtBQUNwQyxjQUFjLGtCQUFrQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbmV4cG9ydCAqIGZyb20gJy4vZG9jdW1lbnQtcmVmLnNlcnZpY2UnXHJcbmV4cG9ydCAqIGZyb20gJy4vd2luZG93LXJlZi5zZXJ2aWNlJ1xyXG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6ZS5zZXJ2aWNlJ1xyXG4iXX0=

package/esm2020/lib/services/resize.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class ResizeService {
+    constructor(eventManager) {
+        this.eventManager = eventManager;
+        this.resizeSubject = new Subject();
+        this.eventManager.addGlobalEventListener('window', 'resize', this.onResize.bind(this));
+        this.eventManager.addGlobalEventListener('window', 'onload', this.onLoaded.bind(this));
+    }
+    /**
+     * Makes resizeSubject become Observable
+     * @returns Observable of resizeSubject
+     */
+    get onResize$() {
+        return this.resizeSubject.asObservable();
+    }
+    /**
+     * Handler of 'resize' event. Passes data throw resizeSubject
+     * @param event Event Object of 'resize' event
+     */
+    onResize(event) {
+        this.resizeSubject.next(event.target);
+    }
+    /**
+     * Handler of 'onload' event. Defines the width of window
+     * @param event Event Object of 'onload' event
+     */
+    onLoaded(event) {
+        this.windowWidth = event.target;
+    }
+}
+ResizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: ResizeService, deps: [{ token: i1.EventManager }], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: ResizeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: ResizeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.EventManager }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/window-ref.service.mjs

@@ -0,0 +1,70 @@
+import { isPlatformBrowser } from '@angular/common';
+import { InjectionToken, PLATFORM_ID, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Create a new injection token for injecting the window into a component.
+ */
+export const WINDOW = new InjectionToken('WindowToken');
+/**
+ * Define abstract class for obtaining reference to the global window object.
+ */
+export class WindowRef {
+    get nativeWindow() {
+        throw new Error('Not implemented.');
+    }
+}
+/**
+ * Define class that implements the abstract class and returns the native window object.
+ */
+export class BrowserWindowRef extends WindowRef {
+    constructor() {
+        super();
+    }
+    /**
+     * @returns window object
+     */
+    get nativeWindow() {
+        return window;
+    }
+}
+BrowserWindowRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BrowserWindowRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BrowserWindowRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BrowserWindowRef });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: BrowserWindowRef, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+/**
+ * Create an factory function that returns the native window object.
+ * @param browserWindowRef Native window object
+ * @param platformId id of platform
+ * @returns type of platform of empty object
+ */
+export function windowFactory(browserWindowRef, platformId) {
+    if (isPlatformBrowser(platformId)) {
+        return browserWindowRef.nativeWindow;
+    }
+    const obj = {
+        setTimeout: (func, time) => { },
+        clearTimeout: (a) => { }
+    };
+    return obj;
+}
+/**
+ * Create a injectable provider for the WindowRef token that uses the BrowserWindowRef class.
+ */
+export const browserWindowProvider = {
+    provide: WindowRef,
+    useClass: BrowserWindowRef
+};
+/**
+ * Create an injectable provider that uses the windowFactory function for returning the native window object.
+ */
+export const windowProvider = {
+    provide: WINDOW,
+    useFactory: windowFactory,
+    deps: [WindowRef, PLATFORM_ID]
+};
+/**
+ * Create an array of providers.
+ */
+export const WINDOW_PROVIDERS = [browserWindowProvider, windowProvider];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93LXJlZi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXNmYy1jb21tb24vc3JjL2xpYi9zZXJ2aWNlcy93aW5kb3ctcmVmLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDcEQsT0FBTyxFQUFrQyxjQUFjLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFeEc7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxjQUFjLENBQUMsYUFBYSxDQUFDLENBQUM7QUFFeEQ7O0dBRUc7QUFDSCxNQUFNLE9BQWdCLFNBQVM7SUFDN0IsSUFBSSxZQUFZO1FBQ2QsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDRjtBQUVEOztHQUVHO0FBRUgsTUFBTSxPQUFPLGdCQUFpQixTQUFRLFNBQVM7SUFDN0M7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7SUFFRDs7T0FFRztJQUNILElBQWEsWUFBWTtRQUN2QixPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDOzs2R0FWVSxnQkFBZ0I7aUhBQWhCLGdCQUFnQjsyRkFBaEIsZ0JBQWdCO2tCQUQ1QixVQUFVOztBQWNYOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLGFBQWEsQ0FDM0IsZ0JBQWtDLEVBQ2xDLFVBQWtCO0lBRWxCLElBQUksaUJBQWlCLENBQUMsVUFBVSxDQUFDLEVBQUU7UUFDakMsT0FBTyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUM7S0FDdEM7SUFDRCxNQUFNLEdBQUcsR0FBRztRQUNWLFVBQVUsRUFBRSxDQUFDLElBQVMsRUFBRSxJQUFTLEVBQUUsRUFBRSxHQUFHLENBQUM7UUFDekMsWUFBWSxFQUFFLENBQUMsQ0FBTSxFQUFFLEVBQUUsR0FBRyxDQUFDO0tBQzlCLENBQUE7SUFDRCxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFrQjtJQUNsRCxPQUFPLEVBQUUsU0FBUztJQUNsQixRQUFRLEVBQUUsZ0JBQWdCO0NBQzNCLENBQUM7QUFFRjs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBb0I7SUFDN0MsT0FBTyxFQUFFLE1BQU07SUFDZixVQUFVLEVBQUUsYUFBYTtJQUN6QixJQUFJLEVBQUUsQ0FBQyxTQUFTLEVBQUUsV0FBVyxDQUFDO0NBQy9CLENBQUM7QUFFRjs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLENBQUMscUJBQXFCLEVBQUUsY0FBYyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1BsYXRmb3JtQnJvd3NlciB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IENsYXNzUHJvdmlkZXIsIEZhY3RvcnlQcm92aWRlciwgSW5qZWN0aW9uVG9rZW4sIFBMQVRGT1JNX0lELCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG4vKipcclxuICogQ3JlYXRlIGEgbmV3IGluamVjdGlvbiB0b2tlbiBmb3IgaW5qZWN0aW5nIHRoZSB3aW5kb3cgaW50byBhIGNvbXBvbmVudC5cclxuICovXHJcbmV4cG9ydCBjb25zdCBXSU5ET1cgPSBuZXcgSW5qZWN0aW9uVG9rZW4oJ1dpbmRvd1Rva2VuJyk7XHJcblxyXG4vKipcclxuICogRGVmaW5lIGFic3RyYWN0IGNsYXNzIGZvciBvYnRhaW5pbmcgcmVmZXJlbmNlIHRvIHRoZSBnbG9iYWwgd2luZG93IG9iamVjdC5cclxuICovXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBXaW5kb3dSZWYge1xyXG4gIGdldCBuYXRpdmVXaW5kb3coKTogV2luZG93IHwgT2JqZWN0IHtcclxuICAgIHRocm93IG5ldyBFcnJvcignTm90IGltcGxlbWVudGVkLicpO1xyXG4gIH1cclxufVxyXG5cclxuLyoqXHJcbiAqIERlZmluZSBjbGFzcyB0aGF0IGltcGxlbWVudHMgdGhlIGFic3RyYWN0IGNsYXNzIGFuZCByZXR1cm5zIHRoZSBuYXRpdmUgd2luZG93IG9iamVjdC5cclxuICovXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIEJyb3dzZXJXaW5kb3dSZWYgZXh0ZW5kcyBXaW5kb3dSZWYge1xyXG4gIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgc3VwZXIoKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEByZXR1cm5zIHdpbmRvdyBvYmplY3RcclxuICAgKi9cclxuICBvdmVycmlkZSBnZXQgbmF0aXZlV2luZG93KCk6IFdpbmRvdyB8IE9iamVjdCB7XHJcbiAgICByZXR1cm4gd2luZG93O1xyXG4gIH1cclxufVxyXG5cclxuLyoqXHJcbiAqIENyZWF0ZSBhbiBmYWN0b3J5IGZ1bmN0aW9uIHRoYXQgcmV0dXJucyB0aGUgbmF0aXZlIHdpbmRvdyBvYmplY3QuXHJcbiAqIEBwYXJhbSBicm93c2VyV2luZG93UmVmIE5hdGl2ZSB3aW5kb3cgb2JqZWN0XHJcbiAqIEBwYXJhbSBwbGF0Zm9ybUlkIGlkIG9mIHBsYXRmb3JtXHJcbiAqIEByZXR1cm5zIHR5cGUgb2YgcGxhdGZvcm0gb2YgZW1wdHkgb2JqZWN0XHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gd2luZG93RmFjdG9yeShcclxuICBicm93c2VyV2luZG93UmVmOiBCcm93c2VyV2luZG93UmVmLFxyXG4gIHBsYXRmb3JtSWQ6IE9iamVjdFxyXG4pOiBXaW5kb3cgfCBPYmplY3Qge1xyXG4gIGlmIChpc1BsYXRmb3JtQnJvd3NlcihwbGF0Zm9ybUlkKSkge1xyXG4gICAgcmV0dXJuIGJyb3dzZXJXaW5kb3dSZWYubmF0aXZlV2luZG93O1xyXG4gIH1cclxuICBjb25zdCBvYmogPSB7XHJcbiAgICBzZXRUaW1lb3V0OiAoZnVuYzogYW55LCB0aW1lOiBhbnkpID0+IHsgfSxcclxuICAgIGNsZWFyVGltZW91dDogKGE6IGFueSkgPT4geyB9XHJcbiAgfVxyXG4gIHJldHVybiBvYmo7XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBDcmVhdGUgYSBpbmplY3RhYmxlIHByb3ZpZGVyIGZvciB0aGUgV2luZG93UmVmIHRva2VuIHRoYXQgdXNlcyB0aGUgQnJvd3NlcldpbmRvd1JlZiBjbGFzcy5cclxuICovXHJcbmV4cG9ydCBjb25zdCBicm93c2VyV2luZG93UHJvdmlkZXI6IENsYXNzUHJvdmlkZXIgPSB7XHJcbiAgcHJvdmlkZTogV2luZG93UmVmLFxyXG4gIHVzZUNsYXNzOiBCcm93c2VyV2luZG93UmVmXHJcbn07XHJcblxyXG4vKipcclxuICogQ3JlYXRlIGFuIGluamVjdGFibGUgcHJvdmlkZXIgdGhhdCB1c2VzIHRoZSB3aW5kb3dGYWN0b3J5IGZ1bmN0aW9uIGZvciByZXR1cm5pbmcgdGhlIG5hdGl2ZSB3aW5kb3cgb2JqZWN0LlxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IHdpbmRvd1Byb3ZpZGVyOiBGYWN0b3J5UHJvdmlkZXIgPSB7XHJcbiAgcHJvdmlkZTogV0lORE9XLFxyXG4gIHVzZUZhY3Rvcnk6IHdpbmRvd0ZhY3RvcnksXHJcbiAgZGVwczogW1dpbmRvd1JlZiwgUExBVEZPUk1fSURdXHJcbn07XHJcblxyXG4vKipcclxuICogQ3JlYXRlIGFuIGFycmF5IG9mIHByb3ZpZGVycy5cclxuICovXHJcbmV4cG9ydCBjb25zdCBXSU5ET1dfUFJPVklERVJTID0gW2Jyb3dzZXJXaW5kb3dQcm92aWRlciwgd2luZG93UHJvdmlkZXJdO1xyXG4iXX0=

package/esm2020/lib/utils/collections.utils.mjs

@@ -0,0 +1,244 @@
+import { CommonConstants } from "../constants";
+import { SortingDirection } from "../enums";
+import { isDefined } from "./common.utils";
+import { isNullOrEmptyString } from "./string.utils";
+/**
+ * Return true if collection not empty
+ * @param collection Array of items
+ * @returns True if collection not empty
+ */
+export function any(collection) {
+    return isDefined(collection) && collection.length > 0;
+}
+/**
+ * Return true if collection has such value
+ * @param collection Array of items
+ * @param value Value to check
+ * @returns True if found value in collection
+ */
+export function hasItem(collection, value) {
+    return any(collection)
+        && collection.findIndex(item => item === value) !== CommonConstants.NOT_FOUND_INDEX;
+}
+/**
+ * Return true if collection has such value by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define check logic
+ * @returns True if found value in collection
+ */
+export function hasItemBy(collection, predicate) {
+    return any(collection) && collection.findIndex(predicate) !== CommonConstants.NOT_FOUND_INDEX;
+}
+/**
+ * Return true if collection of objects has such value as object
+ * @param collection Array of objects
+ * @param property Property name
+ * @param value Value to check
+ * @returns True if found value in collection
+ */
+export function hasObjectItem(collection, // TODO <-- Array<T>
+property, value) {
+    return any(collection)
+        && collection.findIndex(item => item.hasOwnProperty(property)
+            && item[property] === value) !== CommonConstants.NOT_FOUND_INDEX;
+}
+/**
+ * Return value from collection by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define search logic
+ * @returns Value from collection
+ */
+export function firstOrDefault(collection, predicate) {
+    return any(collection) ? collection?.find(predicate) : undefined;
+}
+/**
+ * Return first item from collection
+ * @param collection Array of items
+ * @returns First value from collection
+ */
+export function firstItem(collection) {
+    return any(collection) ? collection[0] : null;
+}
+/**
+ * Return last item from collection
+ * @param collection Array of items
+ * @returns Last value from collection
+ */
+export function lastItem(collection) {
+    return any(collection) ? collection[collection.length - 1] : null;
+}
+/**
+ * Return True if all values match predicate function
+ * @param collection Array of objects
+ * @param predicate Function to define check logic
+ * @returns True if all values match predicate
+ */
+export function all(collection, predicate) {
+    return any(collection) ? collection.filter(predicate).length == collection.length : false;
+}
+/**
+ * Return items from collection by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define search logic
+ * @returns Values from collection
+ */
+export function where(collection, predicate) {
+    return any(collection) ? collection.filter(predicate) : null;
+}
+/**
+ * Return sliced collection by page number and page size
+ * @param collection Array of items
+ * @param page Page number
+ * @param size Page size
+ * @returns Sliced collection
+ */
+export function skip(collection, page, size) {
+    if (any(collection)) {
+        let start = (page - 1) * size;
+        return collection.slice(start, start + size);
+    }
+    return collection;
+}
+/**
+ * Return sorted collection of objects by property
+ * @param collection Array of items
+ * @param property Property name
+ * @param direction Sorting direction
+ * @returns Sorted collection
+ */
+export function sortBy(collection, property, direction) {
+    if (any(collection)) {
+        let _sortFunc = (a, b) => (t1, t2) => (a[property] > b[property] ? t1 : t2);
+        return direction == SortingDirection.Ascending
+            ? collection.sort((a, b) => _sortFunc(a, b)(1, -1))
+            : collection.sort((a, b) => _sortFunc(a, b)(-1, 1));
+    }
+    return collection;
+}
+/**
+ * Return sorted collection of objects by path
+ * @param collection Array of items
+ * @param path Path to property
+ * @param direction Sorting direction
+ * @returns Sorted collection
+ */
+export function sortByPath(collection, path, direction) {
+    if (any(collection)) {
+        if (isNullOrEmptyString(path))
+            throw new Error('Collection utils | Sort By Path function --> Path is empty.');
+        const pathParts = path.split('.');
+        if (!any(pathParts))
+            throw new Error('Collection utils | Sort By Path function --> Path is incorrect.');
+        const partsLength = pathParts.length;
+        collection.sort((a, b) => {
+            var i = 0;
+            while (i < partsLength) {
+                a = a[pathParts[i]];
+                b = b[pathParts[i]];
+                i++;
+            }
+            return direction == SortingDirection.Ascending
+                ? a > b ? 1 : -1
+                : a > b ? -1 : 1;
+        });
+        return collection;
+    }
+    return collection;
+}
+/**
+ * Return collection without matches
+ * @param collection Array of items
+ * @returns Collection without matches
+ */
+export function distinct(collection) {
+    return any(collection)
+        ? collection.filter((value, index, self) => self.indexOf(value) === index)
+        : collection;
+}
+/**
+ * Return sum value from collection items by map function
+ * @param collection Array of items
+ * @param select Map function
+ * @returns Sum value of colection items
+ */
+export function sum(collection, select) {
+    return any(collection)
+        ? collection
+            .map(select)
+            .reduce((a, b) => { return a + b; }, 0)
+        : 0;
+}
+/**
+ * Return max value from collection items by map function
+ * @param collection Array of items
+ * @param select Map function
+ * @returns Max value of collection items
+ */
+export function max(collection, select) {
+    if (any(collection))
+        return Math.max(...collection.map(select));
+    throw new Error('Collection utils | Max function --> Collection is empty.');
+}
+/**
+ * Delete items from collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define remove logic
+ */
+export function remove(collection, predicate) {
+    var i = collection.length;
+    while (i--) {
+        if (predicate(collection[i])) {
+            collection.splice(i, 1);
+        }
+    }
+}
+/**
+ * Add item to collection
+ * @param collection Array of items
+ * @param item New item
+ * @param predicate Function to define if allowed to add new item
+ * @returns True if successfully added
+ */
+export function addItem(collection, item, predicate) {
+    if (!isDefined(collection))
+        collection = new Array();
+    if (isDefined(predicate) && predicate(item))
+        return false;
+    collection.push(item);
+    return true;
+}
+/**
+ * Delete item from collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define remove logic
+ * @returns True if successfully removed
+ */
+export function removeItem(collection, predicate) {
+    const foundItem = firstOrDefault(collection, predicate);
+    if (isDefined(foundItem)) {
+        collection.splice(collection.indexOf(foundItem), 1);
+        return true;
+    }
+    return false;
+}
+export function updateItem(collection, predicate, newItem) {
+    const itemIndex = collection.findIndex(predicate);
+    if (itemIndex !== CommonConstants.NOT_FOUND_INDEX) {
+        const result = collection.slice(0);
+        result[itemIndex] = {
+            ...collection[itemIndex],
+            ...newItem
+        };
+        return result;
+    }
+    return null;
+}
+/**
+ * Return collection or empty if collection is not defined
+ * @param collection Array of items
+ * @returns Collection or empty
+ */
+export function getCollectionOrEmpty(collection) {
+    return isDefined(collection) ? collection : [];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collections.utils.js","sourceRoot":"","sources":["../../../../../projects/ngx-sfc-common/src/lib/utils/collections.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonConstants } from \"../constants\";\r\nimport { SortingDirection } from \"../enums\";\r\nimport { isDefined } from \"./common.utils\";\r\nimport { isNullOrEmptyString } from \"./string.utils\";\r\n\r\n/**\r\n * Return true if collection not empty\r\n * @param collection Array of items\r\n * @returns True if collection not empty\r\n */\r\nexport function any<T>(collection: Array<T> | null | undefined): boolean {\r\n    return isDefined(collection) && (collection as Array<T>).length > 0;\r\n}\r\n\r\n/**\r\n * Return true if collection has such value\r\n * @param collection Array of items\r\n * @param value Value to check\r\n * @returns True if found value in collection\r\n */\r\nexport function hasItem<T>(collection: Array<T>, value: T): boolean {\r\n    return any(collection)\r\n        && collection.findIndex(item => item === value) !== CommonConstants.NOT_FOUND_INDEX;\r\n}\r\n\r\n/**\r\n * Return true if collection has such value by predicate function\r\n * @param collection Array of items\r\n * @param predicate Function to define check logic\r\n * @returns True if found value in collection\r\n */\r\nexport function hasItemBy<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean {\r\n    return any(collection) && collection.findIndex(predicate) !== CommonConstants.NOT_FOUND_INDEX;\r\n}\r\n\r\n/**\r\n * Return true if collection of objects has such value as object\r\n * @param collection Array of objects\r\n * @param property Property name\r\n * @param value Value to check\r\n * @returns True if found value in collection\r\n */\r\nexport function hasObjectItem<T>(collection: Array<any>, // TODO <-- Array<T>\r\n    property: string, value: T): boolean {\r\n    return any(collection)\r\n        && collection.findIndex(item =>\r\n            item.hasOwnProperty(property)\r\n            && item[property] === value) !== CommonConstants.NOT_FOUND_INDEX;\r\n}\r\n\r\n/**\r\n * Return value from collection by predicate function\r\n * @param collection Array of items\r\n * @param predicate Function to define search logic\r\n * @returns Value from collection\r\n */\r\nexport function firstOrDefault<T>(collection: Array<T> | null | undefined,\r\n    predicate: (item: T) => boolean)\r\n    : T | undefined {\r\n    return any(collection) ? collection?.find(predicate) : undefined;\r\n}\r\n\r\n/**\r\n * Return first item from collection\r\n * @param collection Array of items\r\n * @returns First value from collection\r\n */\r\nexport function firstItem<T>(collection: Array<T>): T | null | undefined {\r\n    return any(collection) ? collection[0] : null;\r\n}\r\n\r\n/**\r\n * Return last item from collection\r\n * @param collection Array of items\r\n * @returns Last value from collection\r\n */\r\nexport function lastItem<T>(collection: Array<T>): T | null | undefined {\r\n    return any(collection) ? collection[collection.length - 1] : null;\r\n}\r\n\r\n/**\r\n * Return True if all values match predicate function\r\n * @param collection Array of objects\r\n * @param predicate Function to define check logic\r\n * @returns True if all values match predicate\r\n */\r\nexport function all<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean {\r\n    return any(collection) ? collection.filter(predicate).length == collection.length : false;\r\n}\r\n\r\n/**\r\n * Return items from collection by predicate function\r\n * @param collection Array of items\r\n * @param predicate Function to define search logic\r\n * @returns Values from collection\r\n */\r\nexport function where<T>(collection: Array<T>, predicate: (item: T) => boolean)\r\n    : Array<T> | null | undefined {\r\n    return any(collection) ? collection.filter(predicate) : null;\r\n}\r\n\r\n/**\r\n * Return sliced collection by page number and page size\r\n * @param collection Array of items\r\n * @param page Page number\r\n * @param size Page size\r\n * @returns Sliced collection\r\n */\r\nexport function skip<T>(collection: Array<T>, page: number, size: number): Array<T> {\r\n    if (any(collection)) {\r\n        let start = (page - 1) * size;\r\n        return collection.slice(start, start + size);\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\n/**\r\n * Return sorted collection of objects by property\r\n * @param collection Array of items\r\n * @param property Property name\r\n * @param direction Sorting direction\r\n * @returns Sorted collection\r\n */\r\nexport function sortBy<T>(collection: Array<T>, property: string,\r\n    direction: SortingDirection): Array<T> {\r\n    if (any(collection)) {\r\n        let _sortFunc = (a: any, b: any) =>\r\n            (t1: number, t2: number) =>\r\n                (a[property] > b[property] ? t1 : t2);\r\n\r\n        return direction == SortingDirection.Ascending\r\n            ? collection.sort((a: any, b: any) => _sortFunc(a, b)(1, -1))\r\n            : collection.sort((a: any, b: any) => _sortFunc(a, b)(-1, 1));\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\n/**\r\n * Return sorted collection of objects by path\r\n * @param collection Array of items\r\n * @param path Path to property\r\n * @param direction Sorting direction\r\n * @returns Sorted collection\r\n */\r\nexport function sortByPath<T>(collection: Array<T>, path: string, direction: SortingDirection)\r\n    : Array<T> {\r\n    if (any(collection)) {\r\n        if (isNullOrEmptyString(path))\r\n            throw new Error('Collection utils | Sort By Path function --> Path is empty.');\r\n\r\n        const pathParts = path.split('.');\r\n\r\n        if (!any(pathParts))\r\n            throw new Error('Collection utils | Sort By Path function --> Path is incorrect.');\r\n\r\n        const partsLength = pathParts.length;\r\n\r\n        collection.sort((a: any, b: any) => {\r\n            var i = 0;\r\n            while (i < partsLength) { a = a[pathParts[i]]; b = b[pathParts[i]]; i++; }\r\n\r\n            return direction == SortingDirection.Ascending\r\n                ? a > b ? 1 : -1\r\n                : a > b ? -1 : 1;\r\n        });\r\n\r\n        return collection;\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\n/**\r\n * Return collection without matches\r\n * @param collection Array of items\r\n * @returns Collection without matches\r\n */\r\nexport function distinct<T>(collection: Array<T>): Array<T> {\r\n    return any(collection)\r\n        ? collection.filter((value, index, self) => self.indexOf(value) === index)\r\n        : collection;\r\n}\r\n\r\n/**\r\n * Return sum value from collection items by map function\r\n * @param collection Array of items\r\n * @param select Map function\r\n * @returns Sum value of colection items\r\n */\r\nexport function sum<T>(collection: Array<T>, select: (item: T) => number): number {\r\n    return any(collection)\r\n        ? collection\r\n            .map(select)\r\n            .reduce((a, b) => { return a + b }, 0)\r\n        : 0;\r\n}\r\n\r\n/**\r\n * Return max value from collection items by map function\r\n * @param collection Array of items\r\n * @param select Map function\r\n * @returns Max value of collection items\r\n */\r\nexport function max<T>(collection: Array<T>, select: (item: T) => number): number {\r\n    if (any(collection))\r\n        return Math.max(...collection.map(select));\r\n\r\n    throw new Error('Collection utils | Max function --> Collection is empty.')\r\n}\r\n\r\n/**\r\n * Delete items from collection by predicate\r\n * @param collection Array of items\r\n * @param predicate Function to define remove logic\r\n */\r\nexport function remove<T>(collection: Array<T>, predicate: (item: T) => boolean): void {\r\n    var i = collection.length;\r\n    while (i--) {\r\n        if (predicate(collection[i])) {\r\n            collection.splice(i, 1);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Add item to collection\r\n * @param collection Array of items\r\n * @param item New item\r\n * @param predicate Function to define if allowed to add new item\r\n * @returns True if successfully added\r\n */\r\nexport function addItem<T>(collection: Array<T>, item: T,\r\n    predicate: (item: T) => boolean): boolean {\r\n\r\n    if (!isDefined(collection))\r\n        collection = new Array<T>();\r\n\r\n    if (isDefined(predicate) && predicate(item))\r\n        return false;\r\n\r\n    collection.push(item);\r\n\r\n    return true;\r\n}\r\n\r\n/**\r\n * Delete item from collection by predicate\r\n * @param collection Array of items\r\n * @param predicate Function to define remove logic\r\n * @returns True if successfully removed\r\n */\r\nexport function removeItem<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean {\r\n    const foundItem: T | null | undefined = firstOrDefault(collection, predicate);\r\n    if (isDefined(foundItem)) {\r\n        collection.splice(collection.indexOf(foundItem as T), 1);\r\n        return true;\r\n    }\r\n\r\n    return false;\r\n}\r\n\r\nexport function updateItem<T>(collection: Array<T>, predicate: (item: T) => boolean, newItem: T)\r\n    : Array<T> | null {\r\n    const itemIndex = collection.findIndex(predicate);\r\n\r\n    if (itemIndex !== CommonConstants.NOT_FOUND_INDEX) {\r\n        const result = collection.slice(0);\r\n        result[itemIndex] = {\r\n            ...collection[itemIndex],\r\n            ...newItem\r\n        };\r\n        return result\r\n    }\r\n\r\n    return null;\r\n}\r\n\r\n/**\r\n * Return collection or empty if collection is not defined\r\n * @param collection Array of items\r\n * @returns Collection or empty\r\n */\r\nexport function getCollectionOrEmpty<T>(collection: Array<T>): Array<T> {\r\n    return isDefined(collection) ? collection : [];\r\n}"]}