@bizdoc/core 1.14.9 → 1.14.10

package/esm2020/lib/core/controls/timespan.input.mjs

@@ -0,0 +1,207 @@
+import { Component, Input, HostBinding, Optional, Self } from '@angular/core';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "../pipes/translate.pipe";
+/** */
+export class Timespan {
+    constructor(days, hours, minutes) {
+        this.days = days;
+        this.hours = hours;
+        this.minutes = minutes;
+    }
+}
+/** */
+export class TimespanInput {
+    constructor(ngControl, _fb, _fm, _elRef) {
+        this.ngControl = ngControl;
+        this._fb = _fb;
+        this._fm = _fm;
+        this._elRef = _elRef;
+        this._required = false;
+        this._disabled = false;
+        this.parts = this._fb.group({
+            days: '',
+            hours: '',
+            minutes: ''
+        });
+        this.stateChanges = new Subject();
+        this.id = `timespan-input-${TimespanInput.nextId++}`;
+        this.focused = false;
+        this.errorState = false;
+        this.controlType = 'timespan-input';
+        this.describedBy = '';
+        this._destroy = new Subject();
+        if (this.ngControl != null) {
+            this.ngControl.valueAccessor = this;
+        }
+        _fm.monitor(_elRef.nativeElement, true).subscribe(origin => {
+            this.focused = !!origin;
+            this.stateChanges.next();
+        });
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(plh) {
+        this._placeholder = plh;
+        this.stateChanges.next();
+    }
+    get empty() {
+        const { value: { days, hours, minutes } } = this.parts;
+        return !days && !hours && !minutes;
+    }
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    get required() {
+        return this._required;
+    }
+    set required(req) {
+        this._required = req;
+        this.stateChanges.next();
+    }
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = value;
+        this._disabled ? this.parts.disable() : this.parts.enable();
+        this.stateChanges.next();
+    }
+    setDescribedByIds(ids) {
+        this.describedBy = ids.join(' ');
+    }
+    focus() {
+        this._elRef.nativeElement.querySelector('input').focus();
+    }
+    onContainerClick(event) {
+        if (event.target.tagName.toLowerCase() !== 'input') {
+            this.focus();
+        }
+    }
+    writeValue(obj) {
+        this.value = obj;
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    get value() {
+        const { value: { days, hours, minutes } } = this.parts;
+        if (days || hours || minutes) {
+            return `${days || 0}.${hours || '00'}:${minutes || '00'}:00`;
+        }
+        else
+            return null;
+    }
+    set value(value) {
+        let days = null, hours = null, minutes = null;
+        if (value) {
+            const parts = value.split(':');
+            if (parts[0].indexOf('.') > 0) {
+                const dparts = parts[0].split('.');
+                days = parseInt(dparts[0]);
+                hours = parseInt(dparts[1]);
+            }
+            else {
+                days = 0;
+                hours = parseFloat(parts[0]);
+            }
+            minutes = parseFloat(parts[1]);
+        }
+        this.parts.setValue({ days, hours, minutes });
+        this.stateChanges.next();
+    }
+    ngOnInit() {
+        this.parts.valueChanges.pipe(takeUntil(this._destroy)).
+            subscribe(() => this._onChange(this.value));
+        this.parts.statusChanges.pipe(takeUntil(this._destroy)).
+            subscribe(() => { if (this.parts.touched)
+            this._onTouched(); });
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+        this._fm.stopMonitoring(this._elRef.nativeElement);
+        this.stateChanges.complete();
+    }
+}
+TimespanInput.nextId = 0;
+TimespanInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TimespanInput, deps: [{ token: i1.NgControl, optional: true, self: true }, { token: i1.FormBuilder }, { token: i2.FocusMonitor }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+TimespanInput.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: TimespanInput, selector: "bizdoc-timespan-input", inputs: { placeholder: "placeholder", required: "required", disabled: "disabled", value: "value" }, host: { properties: { "class.floating": "this.shouldLabelFloat", "attr.aria-describedby": "this.describedBy", "id": "this.id" } }, providers: [{ provide: MatFormFieldControl, useExisting: TimespanInput }], ngImport: i0, template: `<div [formGroup]="parts" class="ts-input-container">
+    <input class="ts-input-element" formControlName="days" size="2" pattern="\\d*" #inp>
+    <span class="ts-input-spacer">{{'DaysPart' | translate}}</span>
+    <input class="ts-input-element" formControlName="hours" size="2" max="24" min="0" pattern="\\d*">
+    <span class="ts-input-spacer">{{'HoursPart' | translate}}</span>
+    <input class="ts-input-element" formControlName="minutes" size="2" max="60" min="0" pattern="\\d*">
+    <span class="ts-input-spacer">{{'MinutesPart' | translate}}</span>
+  </div>`, isInline: true, styles: [".ts-input-container{display:flex}.ts-input-element{border:none;background:none;padding:0;outline:none;font:inherit;text-align:center}.ts-input-spacer{opacity:0;font-size:x-small;text-transform:uppercase;transition:opacity .2s}:host.floating .ts-input-spacer{opacity:1}\n"], directives: [{ type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i1.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }], pipes: { "translate": i3.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TimespanInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-timespan-input',
+                    providers: [{ provide: MatFormFieldControl, useExisting: TimespanInput }],
+                    template: `<div [formGroup]="parts" class="ts-input-container">
+    <input class="ts-input-element" formControlName="days" size="2" pattern="\\d*" #inp>
+    <span class="ts-input-spacer">{{'DaysPart' | translate}}</span>
+    <input class="ts-input-element" formControlName="hours" size="2" max="24" min="0" pattern="\\d*">
+    <span class="ts-input-spacer">{{'HoursPart' | translate}}</span>
+    <input class="ts-input-element" formControlName="minutes" size="2" max="60" min="0" pattern="\\d*">
+    <span class="ts-input-spacer">{{'MinutesPart' | translate}}</span>
+  </div>`,
+                    styles: [`.ts-input-container {
+      display: flex;
+    }
+    .ts-input-element {
+      border: none;
+      background: none;
+      padding: 0;
+      outline: none;
+      font: inherit;
+      text-align: center;
+    }
+
+    .ts-input-spacer {
+      opacity: 0;
+
+        font-size: x-small;
+      text-transform: uppercase;
+      transition: opacity 200ms;
+    }
+    :host.floating .ts-input-spacer {
+      opacity: 1;
+    }`],
+                    host: {
+                        '[class.floating]': 'shouldLabelFloat',
+                        '[attr.aria-describedby]': 'describedBy'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i1.FormBuilder }, { type: i2.FocusMonitor }, { type: i0.ElementRef }]; }, propDecorators: { id: [{
+                type: HostBinding
+            }], placeholder: [{
+                type: Input
+            }], shouldLabelFloat: [{
+                type: HostBinding,
+                args: ['class.floating']
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], describedBy: [{
+                type: HostBinding,
+                args: ['attr.aria-describedby']
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timespan.input.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/controls/timespan.input.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, HostBinding, Optional, Self, ElementRef, OnInit } from '@angular/core';\r\nimport { NgControl, ControlValueAccessor, FormBuilder } from '@angular/forms';\r\nimport { MatFormFieldControl } from '@angular/material/form-field';\r\nimport { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\n\r\n/** */\r\nexport class Timespan {\r\n  constructor(public days?: number,\r\n    public hours?: number,\r\n    public minutes?: number) { }\r\n}\r\n@Component({\r\n  selector: 'bizdoc-timespan-input',\r\n  providers: [{ provide: MatFormFieldControl, useExisting: TimespanInput }],\r\n  template: `<div [formGroup]=\"parts\" class=\"ts-input-container\">\r\n    <input class=\"ts-input-element\" formControlName=\"days\" size=\"2\" pattern=\"\\\\d*\" #inp>\r\n    <span class=\"ts-input-spacer\">{{'DaysPart' | translate}}</span>\r\n    <input class=\"ts-input-element\" formControlName=\"hours\" size=\"2\" max=\"24\" min=\"0\" pattern=\"\\\\d*\">\r\n    <span class=\"ts-input-spacer\">{{'HoursPart' | translate}}</span>\r\n    <input class=\"ts-input-element\" formControlName=\"minutes\" size=\"2\" max=\"60\" min=\"0\" pattern=\"\\\\d*\">\r\n    <span class=\"ts-input-spacer\">{{'MinutesPart' | translate}}</span>\r\n  </div>`,\r\n  styles: [`.ts-input-container {\r\n      display: flex;\r\n    }\r\n    .ts-input-element {\r\n      border: none;\r\n      background: none;\r\n      padding: 0;\r\n      outline: none;\r\n      font: inherit;\r\n      text-align: center;\r\n    }\r\n\r\n    .ts-input-spacer {\r\n      opacity: 0;\r\n\r\n        font-size: x-small;\r\n      text-transform: uppercase;\r\n      transition: opacity 200ms;\r\n    }\r\n    :host.floating .ts-input-spacer {\r\n      opacity: 1;\r\n    }`],\r\n  host: {\r\n    '[class.floating]': 'shouldLabelFloat',\r\n    '[attr.aria-describedby]': 'describedBy'\r\n  }\r\n})\r\n  /** */\r\nexport\r\n  class TimespanInput implements MatFormFieldControl<string>, ControlValueAccessor, OnDestroy, OnInit {\r\n  private static nextId = 0;\r\n  private _placeholder: string;\r\n  private _required = false;\r\n  private _disabled = false;\r\n  private _onChange: any;\r\n  private _onTouched: any;\r\n  readonly parts = this._fb.group({\r\n    days: '',\r\n    hours: '',\r\n    minutes: ''\r\n  });\r\n  readonly stateChanges = new Subject<void>();\r\n  @HostBinding() readonly id = `timespan-input-${TimespanInput.nextId++}`;\r\n  @Input() get placeholder() {\r\n    return this._placeholder;\r\n  }\r\n  set placeholder(plh) {\r\n    this._placeholder = plh;\r\n    this.stateChanges.next();\r\n  }\r\n  focused = false;\r\n  get empty(): boolean {\r\n    const { value: { days, hours, minutes } } = this.parts;\r\n\r\n    return !days && !hours && !minutes;\r\n  }\r\n  @HostBinding('class.floating')\r\n  get shouldLabelFloat() {\r\n    return this.focused || !this.empty;\r\n  }\r\n  @Input()\r\n  get required() {\r\n    return this._required;\r\n  }\r\n  set required(req) {\r\n    this._required = req;\r\n    this.stateChanges.next();\r\n  }\r\n  @Input()\r\n  get disabled(): boolean { return this._disabled; }\r\n  set disabled(value: boolean) {\r\n    this._disabled = value;\r\n    this._disabled ? this.parts.disable() : this.parts.enable();\r\n    this.stateChanges.next();\r\n  }\r\n  errorState = false;\r\n  controlType?: string = 'timespan-input';\r\n  @HostBinding('attr.aria-describedby') describedBy = '';\r\n\r\n  setDescribedByIds(ids: string[]) {\r\n    this.describedBy = ids.join(' ');\r\n  }\r\n  focus() {\r\n    this._elRef.nativeElement.querySelector('input').focus();\r\n  }\r\n  onContainerClick(event: MouseEvent): void {\r\n    if ((event.target as Element).tagName.toLowerCase() !== 'input') {\r\n      this.focus();\r\n    }\r\n  }\r\n  writeValue(obj: any): void {\r\n    this.value = obj;\r\n  }\r\n  registerOnChange(fn: any): void {\r\n    this._onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this._onTouched = fn;\r\n  }\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n  }\r\n  @Input() get value(): string | null {\r\n    const { value: { days, hours, minutes } } = this.parts;\r\n    if (days || hours || minutes) {\r\n      return `${days || 0}.${hours || '00'}:${minutes || '00'}:00`;\r\n    }\r\n    else\r\n      return null;\r\n  }\r\n  set value(value: string | null) {\r\n    let days = null, hours = null, minutes = null;\r\n\r\n    if (value) {\r\n      const parts = value.split(':');\r\n      if (parts[0].indexOf('.') > 0) {\r\n        const dparts = parts[0].split('.');\r\n        days = parseInt(dparts[0]); hours = parseInt(dparts[1]);\r\n      }\r\n      else {\r\n        days = 0; hours = parseFloat(parts[0]);\r\n      }\r\n      minutes = parseFloat(parts[1]);\r\n    }\r\n    this.parts.setValue({ days, hours, minutes });\r\n    this.stateChanges.next();\r\n  }\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(@Optional() @Self() public ngControl: NgControl,\r\n    private _fb: FormBuilder, private _fm: FocusMonitor, private _elRef: ElementRef<HTMLElement>) {\r\n    if (this.ngControl != null) {\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n    _fm.monitor(_elRef.nativeElement, true).subscribe(origin => {\r\n      this.focused = !!origin;\r\n      this.stateChanges.next();\r\n    });\r\n  }\r\n  ngOnInit(): void {\r\n    this.parts.valueChanges.pipe(takeUntil(this._destroy)).\r\n      subscribe(() => this._onChange(this.value));\r\n    this.parts.statusChanges.pipe(takeUntil(this._destroy)).\r\n      subscribe(() => { if (this.parts.touched) this._onTouched() });\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n    this._fm.stopMonitoring(this._elRef.nativeElement);\r\n    this.stateChanges.complete();\r\n  }\r\n}\r\n"]}

package/esm2020/lib/core/datasource.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import { map, shareReplay } from 'rxjs/operators';
+import { isObject, mapToArray } from '../core/functions';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/** */
+export class DatasourceService {
+    constructor(_http) {
+        this._http = _http;
+        this._cache = {};
+    }
+    keys(type) {
+        return this.map(type).pipe(map(m => Object.keys(m)));
+    }
+    /**
+     *
+     * @param type
+     * @param key
+     */
+    get(type, key) {
+        return this.map(type).pipe(map(m => m[key] || key));
+    }
+    /**
+     *
+     * @param type
+     * @param value
+     */
+    keyOf(type, value) {
+        return this.map(type).pipe(map(m => Object.keys(m).find(k => m[k] === value)));
+    }
+    /**
+     *
+     * @param type
+     * @param params
+     */
+    map(type, queryParams) {
+        let cacheId = type;
+        if (queryParams) {
+            if (isObject(queryParams))
+                Object.keys(queryParams).forEach(k => cacheId += `${k}${queryParams[k]}`);
+            else
+                cacheId += queryParams.toString();
+        }
+        let observe = this._cache[cacheId];
+        if (!observe) {
+            const params = {};
+            if (queryParams) {
+                if (isObject(queryParams))
+                    Object.assign(params, queryParams);
+                else
+                    params.value = queryParams;
+            }
+            const dataSource = this._http.get(`/api/datatype/${type}`, {
+                params
+            });
+            observe = this._cache[cacheId] = dataSource.pipe(shareReplay());
+        }
+        return observe;
+    }
+    /**
+     *
+     * @param type
+     * @param params
+     */
+    all(type, queryParams) {
+        return this.map(type, queryParams).pipe(map(mapToArray));
+    }
+}
+DatasourceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DatasourceService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+DatasourceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DatasourceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: DatasourceService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/decorators.mjs

@@ -0,0 +1,46 @@
+export const REGISTRY = {};
+/**
+ * @link BizDocComponentFactoryResolver
+ * @param args
+ */
+export function BizDoc(args) {
+    function Decorator(compType) {
+        compType['__bizdoc'] = args.selector;
+    }
+    return Decorator;
+}
+//function getComp(selector) {
+//  const ngModuleDecorator = decoratorOfType(BizDocModule, NgModule);
+//  const componentType = ngModuleDecorator.declarations.find((declaration: Type<any>) => {
+//    // get the @Component decorator
+//    const declarationDecorator = decoratorOfType(declaration, Component);
+//    // find a declaration with the @Component decorator (not a @Directive) with the requested selector
+//    return declarationDecorator != null && declarationDecorator.selector === selector;
+//  });
+//}
+/**
+ * gets a decorator of the requested type off of the given decorated type
+ * @param decoratedType to get decorator annotations off of
+ * @param decoratorType to search for out of all the decorators on decoratedType
+ * @returns decorator from the decoratedType of the decoratorType
+ */
+//export function decoratorOfType<T>(decoratedType: Type<any>, decoratorType: Type<T>): T {
+//  // get all decorators off of the provided type
+//  return Reflect.getOwnPropertyDescriptor(decoratedType, '__annotations__').value.find((annotation: any) =>
+//    // get the decorator that matches the requested type
+//    annotation instanceof decoratorType
+//  );
+//}
+//function components(module) {
+//  const ngModuleDecorator = decoratorOfType(module, NgModule);
+//  const map = {};
+//  ngModuleDecorator.declarations.forEach((declaration: Type<any>) => {
+//    // get the @Component decorator
+//    const declarationDecorator = decoratorOfType(declaration, Component);
+//    // find a declaration with the @Component decorator (not a @Directive) with the requested selector
+//    if (declarationDecorator != null)
+//      map[declarationDecorator.selector] = declaration;
+//  });
+//  return map;
+//}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/firebase.service.mjs

@@ -0,0 +1,50 @@
+import * as firebase from 'firebase/app';
+import { deleteToken, getMessaging, getToken } from "firebase/messaging";
+const DEVICE_TYPE = 'Chrome', ACTIVATION_DELAY = 3000;
+export var FirebaseState;
+(function (FirebaseState) {
+    FirebaseState[FirebaseState["Activated"] = 0] = "Activated";
+})(FirebaseState || (FirebaseState = {}));
+export class FirebaseService {
+    constructor(_config, _session) {
+        this._config = _config;
+        this._session = _session;
+        if (_config && navigator.serviceWorker) {
+            const { apiKey, projectId, senderId, appId } = _config;
+            if (apiKey) {
+                const app = firebase.initializeApp({
+                    apiKey,
+                    projectId,
+                    appId,
+                    messagingSenderId: senderId
+                });
+                this._messaging = getMessaging();
+            }
+        }
+    }
+    get state() {
+        return this._state;
+    }
+    activate() {
+        this._config && this._config.apiKey &&
+            setTimeout(() => this._activate(), this._config.grace || ACTIVATION_DELAY);
+    }
+    async close() {
+        await deleteToken(this._messaging);
+        return this._session.unregisterDevice(DEVICE_TYPE, this._token).subscribe();
+    }
+    _activate() {
+        const { vapidKey } = this._config;
+        navigator.serviceWorker.register('./js/firebase-messaging-sw.js')
+            .then((serviceWorkerRegistration) => {
+            //requestPermission();
+            getToken(this._messaging, { vapidKey, serviceWorkerRegistration }).
+                then(token => {
+                this._token = token;
+                this._session.registerDevice(DEVICE_TYPE, token).subscribe(() => this._state = FirebaseState.Activated);
+            });
+            //onTokenRefresh(token => this._session.registerDevice(DEVICE_TYPE, token).subscribe());
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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