@morozeckiy/dd-lib 0.1.1 → 0.1.2

package/esm2022/lib/core/services/fetcher.service.mjs

@@ -0,0 +1,92 @@
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { isArray } from "@angular/compiler-cli/src/ngtsc/annotations/common";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class FetcherService {
+    constructor(http, apiUrl = 'api') {
+        this.http = http;
+        this.apiUrl = apiUrl;
+        // private apiUrl = 'api';
+        this.payloadMethods = ['post', 'put'];
+    }
+    get(urlParts, options = {}, urlId) {
+        urlParts = urlId ? urlParts.replace(/{[^}]+}/g, urlId.toString()) : urlParts;
+        const url = urlParts ? [this.apiUrl].concat(urlParts).join('/') : this.apiUrl;
+        let params = new HttpParams();
+        for (const key of Object.keys(options)) {
+            if (options[key] != null) {
+                if (options[key].length && isArray(options[key])) {
+                    options[key].forEach((f) => {
+                        params = params.append(key, f);
+                    });
+                }
+                else {
+                    params = params.append(key, options[key]);
+                }
+            }
+        }
+        return this.request('get', url, { params });
+    }
+    post(urlParts, data, options = {}) {
+        const url = [this.apiUrl].concat(urlParts).join('/');
+        if (options?.params) {
+            let params = new HttpParams();
+            for (const key of Object.keys(options.params)) {
+                if (options.params[key] != null) {
+                    params = params.append(key, options.params[key]);
+                }
+            }
+            options.params = params;
+        }
+        return this.request('post', url, options, data);
+    }
+    put(urlParts, options = {}, data) {
+        const url = [this.apiUrl].concat(urlParts).join('/');
+        return this.request('put', url, options, data);
+    }
+    delete(urlParts, options = {}) {
+        const url = [this.apiUrl].concat(urlParts).join('/');
+        return this.request('delete', url, options);
+    }
+    /** перегоняем объкты в форм дату*/
+    createFormData(form) {
+        const formData = new FormData();
+        Object.keys(form).forEach((item) => {
+            formData.append(item, form[item]);
+        });
+        return formData;
+    }
+    request(method, url, options, data) {
+        if (options.headers) {
+            options.headers = new HttpHeaders(options.headers);
+        }
+        let request;
+        options.withCredentials = true;
+        if (this.payloadMethods.includes(method)) {
+            request = this.http[method](url, data, options);
+        }
+        else {
+            request = this.http[method](url, options);
+        }
+        return request.pipe(switchMap((response) => {
+            if (response && response.error) {
+                console.error(`API error with status: ${response.status}`);
+                console.error(response.error);
+            }
+            return of(response);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FetcherService, deps: [{ token: i1.HttpClient }, { token: 'apiUrl' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FetcherService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FetcherService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['apiUrl']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetcher.service.js","sourceRoot":"","sources":["../../../../../../projects/dd-lib/src/lib/core/services/fetcher.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpClient, HttpHeaders, HttpParams} from '@angular/common/http';\r\nimport {Inject, Injectable} from '@angular/core';\r\n\r\nimport {Observable, of} from 'rxjs';\r\nimport {switchMap} from 'rxjs/operators';\r\nimport {isArray} from \"@angular/compiler-cli/src/ngtsc/annotations/common\";\r\n\r\nexport interface HttpIResponse<T> {\r\n  error: string;\r\n  errorCode: string;\r\n  message: null | string;\r\n  redirect: null | string;\r\n  systemMessage: null | string;\r\n  result: 'OK' | 'ERROR' | 'FAIL';\r\n  value: T;\r\n}\r\n\r\ntype PayloadMethod = 'post' | 'put' | 'get' | 'delete';\r\n\r\n@Injectable({providedIn: 'root'}) /** сервис обработки запросов к api */\r\nexport class FetcherService {\r\n  // private apiUrl = 'api';\r\n  private readonly payloadMethods: string[] = ['post', 'put'];\r\n\r\n  constructor(private http: HttpClient, @Inject('apiUrl') private apiUrl: string = 'api') {\r\n  }\r\n\r\n  public get<R>(urlParts: string, options: any = {}, urlId?: string | number): Observable<R> {\r\n    urlParts = urlId ? urlParts.replace(/{[^}]+}/g, urlId.toString()) : urlParts;\r\n    const url: string = urlParts ? [this.apiUrl].concat(urlParts).join('/') : this.apiUrl;\r\n    let params = new HttpParams();\r\n    for (const key of Object.keys(options)) {\r\n      if (options[key] != null) {\r\n        if (options[key].length && isArray(options[key])) {\r\n          options[key].forEach((f: string | number | boolean) => {\r\n            params = params.append(key, f);\r\n          });\r\n        } else {\r\n          params = params.append(key, options[key]);\r\n        }\r\n      }\r\n    }\r\n    return this.request('get', url, {params});\r\n  }\r\n\r\n  public post<R>(urlParts: string[] | string, data?: any, options: any = {}): Observable<R> {\r\n    const url: string = [this.apiUrl].concat(urlParts).join('/');\r\n    if (options?.params) {\r\n      let params = new HttpParams();\r\n      for (const key of Object.keys(options.params)) {\r\n        if (options.params[key] != null) {\r\n          params = params.append(key, options.params[key]);\r\n        }\r\n      }\r\n      options.params = params;\r\n    }\r\n    return this.request('post', url, options, data);\r\n  }\r\n\r\n  public put<R>(urlParts: string[] | string, options: any = {}, data: any): Observable<any> {\r\n    const url: string = [this.apiUrl].concat(urlParts).join('/');\r\n    return this.request('put', url, options, data);\r\n  }\r\n\r\n  public delete<R>(urlParts: string[] | string, options: any = {}): Observable<R> {\r\n    const url: string = [this.apiUrl].concat(urlParts).join('/');\r\n    return this.request('delete', url, options);\r\n  }\r\n\r\n  /** перегоняем объкты в форм дату*/\r\n  public createFormData(form: { [x: string]: any }) {\r\n    const formData: FormData = new FormData();\r\n    Object.keys(form).forEach((item: string) => {\r\n      formData.append(item, form[item]);\r\n    });\r\n    return formData;\r\n  }\r\n\r\n  private request<R>(method: PayloadMethod, url: string, options: any, data?: any): Observable<R> {\r\n    if (options.headers) {\r\n      options.headers = new HttpHeaders(options.headers);\r\n    }\r\n    let request: Observable<any>;\r\n    options.withCredentials = true;\r\n\r\n    if (this.payloadMethods.includes(method)) {\r\n      request = this.http[method as 'post' | 'put'](url, data, options);\r\n    } else {\r\n      request = (this.http as any)[method](url, options);\r\n    }\r\n\r\n    return request.pipe(\r\n      switchMap((response: any) => {\r\n        if (response && response.error) {\r\n          console.error(`API error with status: ${response.status}`);\r\n          console.error(response.error);\r\n        }\r\n        return of(response);\r\n      }),\r\n      // catchError((error: any) => {\r\n      // console.timeEnd('Время выполнения - ' + url);\r\n      // if (error.status !== 403) {\r\n      // console.log(error);\r\n      // }\r\n      // return of(error);\r\n      // }),\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/services/interceptors.service.mjs

@@ -0,0 +1,27 @@
+import { HttpErrorResponse, } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class InterceptorsService {
+    constructor(router) {
+        this.router = router;
+    }
+    /** перехватчик состояния запросов к api */
+    intercept(req, next) {
+        return next.handle(req).pipe(catchError(err => {
+            if (err instanceof HttpErrorResponse) {
+                if (err.status >= 500) {
+                    this.router.navigate(['tech-works']);
+                }
+            }
+            throw err;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InterceptorsService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InterceptorsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InterceptorsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Router }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/svg-icons.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SvgIconsService {
+    constructor() {
+        this.registry = new Map();
+    }
+    registerIcons(icons) {
+        icons.forEach((icon) => this.registry.set(icon.name, icon.data));
+    }
+    getIcon(iconName) {
+        if (!this.registry.has(iconName)) {
+            // eslint-disable-next-line no-console
+            console.warn(`We could not find the icon with name ${iconName}, did you add it to the icon registry?`);
+        }
+        return this.registry.get(iconName);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SvgIconsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SvgIconsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SvgIconsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/theme-constructor.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ThemeConstructorService {
+    get getTheme() {
+        return this.themeConfigurator.theme;
+    }
+    constructor(rendererFactory) {
+        this.rendererFactory = rendererFactory;
+        this.renderer = rendererFactory.createRenderer(null, null);
+    }
+    setThemeConfiguratorRoot(document) {
+        this.themeConfigurator = new ThemeConfigurator(document, this.renderer);
+        this.isDarkTheme = this.themeConfigurator.isDarkThemeObservable;
+    }
+    changeTheme(darkMode) {
+        this.themeConfigurator.setTheme(darkMode);
+    }
+    switchTheme() {
+        this.themeConfigurator.switchTheme();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeConstructorService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeConstructorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeConstructorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }] });
+export class ThemeConfigurator {
+    set theme(value) {
+        localStorage.setItem('theme', value.toString());
+        this.isDarkTheme$.next(value);
+    }
+    get theme() {
+        return this.isDarkTheme$.getValue();
+    }
+    constructor(document, renderer) {
+        this.document = document;
+        this.renderer = renderer;
+        this.isDarkTheme$ = new BehaviorSubject(false);
+        this.isDarkThemeObservable = this.isDarkTheme$.asObservable();
+        this.isDarkThemeObservable.subscribe(ref => this.setTheme(ref));
+        const theme = localStorage.getItem('theme');
+        if (!theme) {
+            this.theme = false;
+        }
+        else {
+            this.theme = localStorage.getItem('theme') !== 'false';
+        }
+    }
+    switchTheme() {
+        this.theme = !this.theme;
+    }
+    setTheme(isDarkMode) {
+        if (!this.document) {
+            return;
+        }
+        const hostClass = isDarkMode ? 'theme-dark' : 'theme-light';
+        this.renderer.setAttribute(this.document.body, 'class', hostClass);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/validators.service.mjs

@@ -0,0 +1,73 @@
+import { Injectable } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ValidatorsService {
+    constructor() { }
+    /** валидатор совпадения пароллей. При использовании указывать поля pswd & confPswd*/
+    static passEqual(el) {
+        if (!el.get('pswd') || !el.get('oldPswd')) {
+            return null;
+        }
+        if (!(el.dirty || el.touched) || el.get('pswd')?.value === el.get('confPswd')?.value) {
+            return null;
+        }
+        return {
+            passEqual: 'Пароли не совпадают',
+        };
+    }
+    static passNotEqual(el) {
+        if (!el.get('pswd') || !el.get('oldPswd')) {
+            return null;
+        }
+        if (!(el.dirty || el.touched) || el.get('pswd')?.value !== el.get('oldPswd')?.value) {
+            return null;
+        }
+        return {
+            passNotEqual: 'Старый и новый пароли не должны совпадать',
+        };
+    }
+    static wrongLogin() {
+        return {
+            wrongMail: 'Неверный логин!',
+        };
+    }
+    static wrongLoginOrPswd() {
+        return {
+            wrongLogin: 'Неверный логин или пароль!',
+        };
+    }
+    static existLogin() {
+        return {
+            mailErr: 'Пользователь с таким адресом уже зарегистрирован.',
+        };
+    }
+    /** валидатор имени*/
+    static getNameValid() {
+        return [Validators.required, Validators.pattern(/^[A-ZА-Яa-zа-яЁё0-9- .]+$/), Validators.maxLength(35)];
+    }
+    /** валидатор email*/
+    static getMailValid(el) {
+        const pattern = /^([A-Za-z0-9+_-]+\.)*[A-Za-z0-9+_-]+@[A-Za-z0-9+_-]+(\.[A-Za-z0-9+_-]+)*\.[A-Za-z]{2,6}$/;
+        if (!el?.value) {
+            return of({
+                required: 'Это поле обязательно для заполнения',
+            });
+        }
+        else if (!pattern.test(el.value) && el.value !== 'test_admin' && el.value !== 'admin') {
+            return of({
+                email: 'Некорректно введены данные',
+            });
+        }
+        else {
+            return of(null);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidatorsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidatorsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ValidatorsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/tools.mjs

@@ -0,0 +1,128 @@
+export function compare(field, order, ...args) {
+    let len = args.length;
+    if (len === 0) {
+        return (a, b) => (a < b && -1) || (a > b && 1) || 0;
+    }
+    if (len === 1) {
+        switch (typeof field) {
+            case 'number':
+                return field < 0
+                    ? (a, b) => (a < b && 1) || (a > b && -1) || 0
+                    : (a, b) => (a < b && -1) || (a > b && 1) || 0;
+            case 'string':
+                return (a, b) => (a[field] ? a[field].toLowerCase() : '' < b[field] ? b[field].toLowerCase() : '' && -1) ||
+                    (a[field] ? a[field].toLowerCase() : '' > b[field] ? b[field].toLowerCase() : '' && 1) ||
+                    0;
+        }
+    }
+    if (field && len === 2 && typeof order === 'number') {
+        return order < 0
+            ? (a, b) => (b[field] || '').toLowerCase().localeCompare((a[field] || '').toLowerCase())
+            : (a, b) => (a[field] || '').toLowerCase().localeCompare((b[field] || '').toLowerCase());
+    }
+    let fields;
+    let orders;
+    if (typeof field === 'object') {
+        fields = Object.getOwnPropertyNames(field);
+        orders = fields.map(key => field[key]);
+        len = fields.length;
+    }
+    else {
+        fields = new Array(len);
+        orders = new Array(len);
+        for (let i = len; i--;) {
+            fields[i] = args[i];
+            orders[i] = 1;
+        }
+    }
+    return (a, b) => {
+        for (let i = 0; i < len; i++) {
+            if (a[fields[i]].toLowerCase() < b[fields[i]].toLowerCase()) {
+                return orders[i];
+            }
+            if (a[fields[i]].toLowerCase() > b[fields[i]].toLowerCase()) {
+                return -orders[i];
+            }
+        }
+        return 0;
+    };
+}
+// export function parseDate(value) {
+//     if (value && value.length === 6) {
+//         const year = parseInt(value.slice(2, 6), 10);
+//         const month = parseInt(value.slice(0, 2), 10) - 1;
+//         return new Date(year, month);
+//     }
+// }
+export function rndRgb() {
+    const x = Math.floor(Math.random() * 256);
+    const y = Math.floor(Math.random() * 256);
+    const z = Math.floor(Math.random() * 256);
+    return 'rgb(' + x + ',' + y + ',' + z + ')';
+}
+export function setMinDate() {
+    let curYear = new Date().getFullYear();
+    let curMonth = new Date().getMonth();
+    const curDay = new Date().getDate();
+    if (curMonth < 6) {
+        curYear -= 1;
+        curMonth = curMonth - 6 + 12;
+    }
+    else {
+        curMonth -= 6;
+    }
+    return new Date(curYear, curMonth, curDay);
+}
+export function isNil(value) {
+    return value === null || typeof value === 'undefined';
+}
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function isObject(value) {
+    return value !== null && typeof value === 'object';
+}
+export function getProperty(value, key) {
+    if (isNil(value) || !isObject(value)) {
+        return undefined;
+    }
+    const keys = key.split('.');
+    let result = value[keys.shift()];
+    for (const k of keys) {
+        if (isNil(result) || !isObject(result)) {
+            return undefined;
+        }
+        result = result[k];
+    }
+    return result;
+}
+export function isMobile() {
+    return Android() || BlackBerry() || iOS() || Opera() || Windows();
+}
+export function Android() {
+    return !!navigator.userAgent.match(/Android/i);
+}
+export function BlackBerry() {
+    return !!navigator.userAgent.match(/BlackBerry/i);
+}
+export function iOS() {
+    return !!navigator.userAgent.match(/iPhone|iPad|iPod/i);
+}
+export function Opera() {
+    return !!navigator.userAgent.match(/Opera Mini/i);
+}
+export function Windows() {
+    return !!navigator.userAgent.match(/IEMobile/i) || navigator.userAgent.match(/WPDesktop/i);
+}
+export function dataURLtoFile(dataUrl, filename) {
+    const arr = dataUrl.split(',');
+    const mime = arr[0].match(/:(.*?);/)[1];
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+        u8arr[n] = bstr.charCodeAt(n);
+    }
+    return new File([u8arr], filename, { type: mime });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../../../projects/dd-lib/src/lib/core/tools.ts"],"names":[],"mappings":"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","sourcesContent":["export function compare(field?: any, order?: number, ...args: undefined[]): any {\n  let len = args.length;\n  if (len === 0) {\n    return (a: number, b: number) => (a < b && -1) || (a > b && 1) || 0;\n  }\n  if (len === 1) {\n    switch (typeof field) {\n      case 'number':\n        return field < 0\n          ? (a: number, b: number) => (a < b && 1) || (a > b && -1) || 0\n          : (a: number, b: number) => (a < b && -1) || (a > b && 1) || 0;\n      case 'string':\n        return (a: { [x: string]: string }, b: { [x: string]: string }) =>\n          (a[field] ? a[field].toLowerCase() : '' < b[field] ? b[field].toLowerCase() : '' && -1) ||\n          (a[field] ? a[field].toLowerCase() : '' > b[field] ? b[field].toLowerCase() : '' && 1) ||\n          0;\n    }\n  }\n  if (field && len === 2 && typeof order === 'number') {\n    return order < 0\n      ? (\n          a: { [x: string]: any },\n          b: {\n            [x: string]: any;\n          },\n        ) => (b[field] || '').toLowerCase().localeCompare((a[field] || '').toLowerCase())\n      : (\n          a: { [x: string]: any },\n          b: {\n            [x: string]: any;\n          },\n        ) => (a[field] || '').toLowerCase().localeCompare((b[field] || '').toLowerCase());\n  }\n  let fields: any[];\n  let orders: any[];\n  if (typeof field === 'object') {\n    fields = Object.getOwnPropertyNames(field);\n    orders = fields.map(key => field[key]);\n    len = fields.length;\n  } else {\n    fields = new Array(len);\n    orders = new Array(len);\n    for (let i = len; i--; ) {\n      fields[i] = args[i];\n      orders[i] = 1;\n    }\n  }\n  return (\n    a: { [x: string]: { toLowerCase: () => number } },\n    b: { [x: string]: { toLowerCase: () => number } },\n  ) => {\n    for (let i = 0; i < len; i++) {\n      if (a[fields[i]].toLowerCase() < b[fields[i]].toLowerCase()) {\n        return orders[i];\n      }\n      if (a[fields[i]].toLowerCase() > b[fields[i]].toLowerCase()) {\n        return -orders[i];\n      }\n    }\n    return 0;\n  };\n}\n\n// export function parseDate(value) {\n//     if (value && value.length === 6) {\n//         const year = parseInt(value.slice(2, 6), 10);\n//         const month = parseInt(value.slice(0, 2), 10) - 1;\n//         return new Date(year, month);\n//     }\n// }\n\nexport function rndRgb() {\n  const x = Math.floor(Math.random() * 256);\n  const y = Math.floor(Math.random() * 256);\n  const z = Math.floor(Math.random() * 256);\n  return 'rgb(' + x + ',' + y + ',' + z + ')';\n}\n\nexport function setMinDate() {\n  let curYear = new Date().getFullYear();\n  let curMonth = new Date().getMonth();\n  const curDay = new Date().getDate();\n  if (curMonth < 6) {\n    curYear -= 1;\n    curMonth = curMonth - 6 + 12;\n  } else {\n    curMonth -= 6;\n  }\n  return new Date(curYear, curMonth, curDay);\n}\n\nexport function isNil(value: any): value is null | undefined {\n  return value === null || typeof value === 'undefined';\n}\n\nexport function isString(value: any): value is string {\n  return typeof value === 'string';\n}\n\nexport function isObject(value: any): boolean {\n  return value !== null && typeof value === 'object';\n}\n\nexport function getProperty(value: { [key: string]: any }, key: string): any {\n  if (isNil(value) || !isObject(value)) {\n    return undefined;\n  }\n\n  const keys: string[] = key.split('.');\n  let result: any = value[keys.shift()!];\n\n  for (const k of keys) {\n    if (isNil(result) || !isObject(result)) {\n      return undefined;\n    }\n\n    result = result[k];\n  }\n\n  return result;\n}\n\nexport function isMobile() {\n  return Android() || BlackBerry() || iOS() || Opera() || Windows();\n}\n\nexport function Android() {\n  return !!navigator.userAgent.match(/Android/i);\n}\n\nexport function BlackBerry() {\n  return !!navigator.userAgent.match(/BlackBerry/i);\n}\n\nexport function iOS() {\n  return !!navigator.userAgent.match(/iPhone|iPad|iPod/i);\n}\n\nexport function Opera() {\n  return !!navigator.userAgent.match(/Opera Mini/i);\n}\n\nexport function Windows() {\n  return !!navigator.userAgent.match(/IEMobile/i) || navigator.userAgent.match(/WPDesktop/i);\n}\n\nexport function dataURLtoFile(dataUrl: string, filename: string) {\n  const arr = dataUrl.split(',');\n  const mime = (arr as any)[0].match(/:(.*?);/)[1];\n  const bstr = atob(arr[1]);\n  let n = bstr.length;\n  const u8arr = new Uint8Array(n);\n\n  while (n--) {\n    u8arr[n] = bstr.charCodeAt(n);\n  }\n\n  return new File([u8arr], filename, { type: mime });\n}\n"]}

package/esm2022/lib/core/tooltip/tooltip.component.mjs

@@ -0,0 +1,27 @@
+import { ChangeDetectionStrategy, Component, Inject, InjectionToken, TemplateRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TriangleDirective } from "../directives/triangle.directive";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export const TOOLTIP_DATA = new InjectionToken('Подсказка');
+export class TooltipComponent {
+    get asString() {
+        return typeof this.tooltipData === 'string' ? this.tooltipData : false;
+    }
+    get asTemplate() {
+        return this.tooltipData instanceof TemplateRef ? this.tooltipData : false;
+    }
+    constructor(tooltipData) {
+        this.tooltipData = tooltipData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TooltipComponent, deps: [{ token: TOOLTIP_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: TooltipComponent, isStandalone: true, selector: "dd-tooltip", ngImport: i0, template: "<div class=\"tooltip-container\">\r\n  @if (asString; as string) {\r\n  {{ string }}\r\n  } @if (asTemplate; as template) {\r\n  <ng-template [ngTemplateOutlet]=\"template\"></ng-template>\r\n  }\r\n  <svg class=\"tooltip-container__triangle\" width=\"16\" height=\"16\">\r\n    <polyline points=\"8,0 0,8 8,16\"></polyline>\r\n  </svg>\r\n</div>\r\n", styles: [":host{position:relative}.tooltip-container{position:relative;display:block;max-width:312px;padding:6px 12px;background:var(--white-color);border-radius:8px;box-sizing:border-box;box-shadow:0 14px 64px -4px #18274b0f,0 8px 22px -6px #18274b0f}.tooltip-container__triangle{width:16px;height:16px;position:absolute;fill:#fff;stroke:#fff;box-shadow:#18274b0f 0 14px 64px -4px,#18274b0f 0 8px 22px -6px}:host-context(.left) svg{top:calc(50% - 8px);right:-8px;rotate:180deg}:host-context(.right) svg{top:calc(50% - 8px);left:-8px}:host-context(.top) svg{right:calc(50% - 8px);bottom:-8px;rotate:-90deg}:host-context(.bottom) svg{right:calc(50% - 8px);top:-8px;rotate:90deg}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dd-tooltip', standalone: true, imports: [CommonModule, TriangleDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"tooltip-container\">\r\n  @if (asString; as string) {\r\n  {{ string }}\r\n  } @if (asTemplate; as template) {\r\n  <ng-template [ngTemplateOutlet]=\"template\"></ng-template>\r\n  }\r\n  <svg class=\"tooltip-container__triangle\" width=\"16\" height=\"16\">\r\n    <polyline points=\"8,0 0,8 8,16\"></polyline>\r\n  </svg>\r\n</div>\r\n", styles: [":host{position:relative}.tooltip-container{position:relative;display:block;max-width:312px;padding:6px 12px;background:var(--white-color);border-radius:8px;box-sizing:border-box;box-shadow:0 14px 64px -4px #18274b0f,0 8px 22px -6px #18274b0f}.tooltip-container__triangle{width:16px;height:16px;position:absolute;fill:#fff;stroke:#fff;box-shadow:#18274b0f 0 14px 64px -4px,#18274b0f 0 8px 22px -6px}:host-context(.left) svg{top:calc(50% - 8px);right:-8px;rotate:180deg}:host-context(.right) svg{top:calc(50% - 8px);left:-8px}:host-context(.top) svg{right:calc(50% - 8px);bottom:-8px;rotate:-90deg}:host-context(.bottom) svg{right:calc(50% - 8px);top:-8px;rotate:90deg}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TOOLTIP_DATA]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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