barsa-novin-ray-core 0.0.2

package/README.md

@@ -0,0 +1,25 @@
+# BarsaNovinRayCore
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 10.0.6.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project BarsaNovinRayCore` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project BarsaNovinRayCore`.
+
+> Note: Don't forget to add `--project BarsaNovinRayCore` or else it will be added to the default project in your `angular.json` file.
+
+## Build
+
+Run `ng build BarsaNovinRayCore` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build BarsaNovinRayCore`, go to the dist folder `cd dist/barsa-novin-ray-core` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test BarsaNovinRayCore` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).

package/esm2020/barsa-novin-ray-core.mjs

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

package/esm2020/lib/abstract-classes/application-base.mjs

@@ -0,0 +1,24 @@
+import { Input, Component, ChangeDetectionStrategy } from '@angular/core';
+import { BaseComponent } from '../base.component';
+import * as i0 from "@angular/core";
+export class ApplicationBaseComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.systemList = [];
+    }
+}
+ApplicationBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ApplicationBaseComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+ApplicationBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: ApplicationBaseComponent, selector: "bnrc-application-base", inputs: { context: "context", selectedSystemId: "selectedSystemId" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ApplicationBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-application-base',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { context: [{
+                type: Input
+            }], selectedSystemId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/abstract-classes/barsa-api.mjs

@@ -0,0 +1,40 @@
+export class BarsaApi {
+    static get GanttChartHelper() {
+        return GanttChartHelper;
+    }
+    static get Ext() {
+        return Ext;
+    }
+    static get Common() {
+        return Common;
+    }
+    static get Util() {
+        return Util;
+    }
+    static get Ul() {
+        return Ul;
+    }
+    static get Ui() {
+        return Ui;
+    }
+    static get Bw() {
+        return Bw;
+    }
+    static get BBB() {
+        return BBB;
+    }
+    static get LoginForm() {
+        return LoginForm;
+    }
+    static get LoginAction() {
+        return LoginAction;
+    }
+    static get LoginFormUi() {
+        return LoginFormUi;
+    }
+    static get LoginFormData() {
+        return LoginFormData;
+    }
+}
+BarsaApi.idGenerator = -10000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFyc2EtYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYmFyc2Etbm92aW4tcmF5LWNvcmUvc3JjL2xpYi9hYnN0cmFjdC1jbGFzc2VzL2JhcnNhLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFhQSxNQUFNLE9BQU8sUUFBUTtJQUVqQixNQUFNLEtBQUssZ0JBQWdCO1FBQ3ZCLE9BQU8sZ0JBQWdCLENBQUM7SUFDNUIsQ0FBQztJQUNELE1BQU0sS0FBSyxHQUFHO1FBQ1YsT0FBTyxHQUFHLENBQUM7SUFDZixDQUFDO0lBQ0QsTUFBTSxLQUFLLE1BQU07UUFDYixPQUFPLE1BQU0sQ0FBQztJQUNsQixDQUFDO0lBQ0QsTUFBTSxLQUFLLElBQUk7UUFDWCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0lBQ0QsTUFBTSxLQUFLLEVBQUU7UUFDVCxPQUFPLEVBQUUsQ0FBQztJQUNkLENBQUM7SUFDRCxNQUFNLEtBQUssRUFBRTtRQUNULE9BQU8sRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUNELE1BQU0sS0FBSyxFQUFFO1FBQ1QsT0FBTyxFQUFFLENBQUM7SUFDZCxDQUFDO0lBQ0QsTUFBTSxLQUFLLEdBQUc7UUFDVixPQUFPLEdBQUcsQ0FBQztJQUNmLENBQUM7SUFDRCxNQUFNLEtBQUssU0FBUztRQUNoQixPQUFPLFNBQVMsQ0FBQztJQUNyQixDQUFDO0lBQ0QsTUFBTSxLQUFLLFdBQVc7UUFDbEIsT0FBTyxXQUFXLENBQUM7SUFDdkIsQ0FBQztJQUNELE1BQU0sS0FBSyxXQUFXO1FBQ2xCLE9BQU8sV0FBVyxDQUFDO0lBQ3ZCLENBQUM7SUFDRCxNQUFNLEtBQUssYUFBYTtRQUNwQixPQUFPLGFBQWEsQ0FBQztJQUN6QixDQUFDOztBQXBDTSxvQkFBVyxHQUFHLENBQUMsS0FBSyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlY2xhcmUgY29uc3QgQ29tbW9uOiBhbnk7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBVbDogYW55O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgVWk6IGFueTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IFV0aWw6IGFueTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IEJ3OiBhbnk7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBCQkI6IGFueTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IExvZ2luQWN0aW9uOiBhbnk7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBVbHZNYWluQ3RybDogYW55O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgTG9naW5Gb3JtVWk6IGFueTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IExvZ2luRm9ybURhdGE6IGFueTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IExvZ2luRm9ybTogYW55O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgRXh0OiBhbnk7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBHYW50dENoYXJ0SGVscGVyOiBhbnk7XG5leHBvcnQgY2xhc3MgQmFyc2FBcGkge1xuICAgIHN0YXRpYyBpZEdlbmVyYXRvciA9IC0xMDAwMDtcbiAgICBzdGF0aWMgZ2V0IEdhbnR0Q2hhcnRIZWxwZXIoKTogYW55IHtcbiAgICAgICAgcmV0dXJuIEdhbnR0Q2hhcnRIZWxwZXI7XG4gICAgfVxuICAgIHN0YXRpYyBnZXQgRXh0KCk6IGFueSB7XG4gICAgICAgIHJldHVybiBFeHQ7XG4gICAgfVxuICAgIHN0YXRpYyBnZXQgQ29tbW9uKCk6IGFueSB7XG4gICAgICAgIHJldHVybiBDb21tb247XG4gICAgfVxuICAgIHN0YXRpYyBnZXQgVXRpbCgpOiBhbnkge1xuICAgICAgICByZXR1cm4gVXRpbDtcbiAgICB9XG4gICAgc3RhdGljIGdldCBVbCgpOiBhbnkge1xuICAgICAgICByZXR1cm4gVWw7XG4gICAgfVxuICAgIHN0YXRpYyBnZXQgVWkoKTogYW55IHtcbiAgICAgICAgcmV0dXJuIFVpO1xuICAgIH1cbiAgICBzdGF0aWMgZ2V0IEJ3KCk6IGFueSB7XG4gICAgICAgIHJldHVybiBCdztcbiAgICB9XG4gICAgc3RhdGljIGdldCBCQkIoKTogYW55IHtcbiAgICAgICAgcmV0dXJuIEJCQjtcbiAgICB9XG4gICAgc3RhdGljIGdldCBMb2dpbkZvcm0oKTogYW55IHtcbiAgICAgICAgcmV0dXJuIExvZ2luRm9ybTtcbiAgICB9XG4gICAgc3RhdGljIGdldCBMb2dpbkFjdGlvbigpOiBhbnkge1xuICAgICAgICByZXR1cm4gTG9naW5BY3Rpb247XG4gICAgfVxuICAgIHN0YXRpYyBnZXQgTG9naW5Gb3JtVWkoKTogYW55IHtcbiAgICAgICAgcmV0dXJuIExvZ2luRm9ybVVpO1xuICAgIH1cbiAgICBzdGF0aWMgZ2V0IExvZ2luRm9ybURhdGEoKTogYW55IHtcbiAgICAgICAgcmV0dXJuIExvZ2luRm9ybURhdGE7XG4gICAgfVxufVxuIl19

package/esm2020/lib/abstract-classes/field-base.mjs

@@ -0,0 +1,167 @@
+import { Input, Output, EventEmitter, Component, ChangeDetectionStrategy, Self, Optional, Inject } from '@angular/core';
+import { BehaviorSubject, combineLatest, Subject } from 'rxjs';
+import { distinctUntilChanged, map, takeUntil } from 'rxjs/operators';
+import { DIALOG_SERVICE } from '../../public-api';
+import { BaseComponent } from '../base.component';
+import { BarsaApi } from './barsa-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../services";
+import * as i2 from "../pipes";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/platform-browser";
+import * as i5 from "../date-services";
+export class FieldBaseComponent extends BaseComponent {
+    constructor(_portalService, _bbbPipe, _picFieldSrc, _numeralPipe, _el, _cdr, _renderer2, _activatedRoute, _domSanitizer, _dialogService, _uploadService, _dateService) {
+        super();
+        this._portalService = _portalService;
+        this._bbbPipe = _bbbPipe;
+        this._picFieldSrc = _picFieldSrc;
+        this._numeralPipe = _numeralPipe;
+        this._el = _el;
+        this._cdr = _cdr;
+        this._renderer2 = _renderer2;
+        this._activatedRoute = _activatedRoute;
+        this._domSanitizer = _domSanitizer;
+        this._dialogService = _dialogService;
+        this._uploadService = _uploadService;
+        this._dateService = _dateService;
+        this.valueChange = new EventEmitter();
+        this.formmatedValue = new EventEmitter();
+        this._refreshSource = new Subject();
+        this._valueChangedSource = new Subject();
+        this._disableChangedSource = new BehaviorSubject(false);
+        this._readonlyChangedSource = new BehaviorSubject(false);
+        this.refresh$ = this._refreshSource.asObservable().pipe(takeUntil(this._onDestroy$));
+        this.value$ = this._valueChangedSource.asObservable().pipe(takeUntil(this._onDestroy$));
+        this.disable$ = this._disableChangedSource
+            .asObservable()
+            .pipe(takeUntil(this._onDestroy$), distinctUntilChanged());
+        this.readonly$ = this._readonlyChangedSource
+            .asObservable()
+            .pipe(takeUntil(this._onDestroy$), distinctUntilChanged());
+        this.disableOrReadonly$ = combineLatest([this.readonly$, this.disable$]).pipe(map(([disable, readonly]) => disable || readonly), distinctUntilChanged());
+        this.el = _el;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.context) {
+            this.Setting = this.context ? this.context.Setting : null;
+            const readonly = this.context?.readOnly;
+            this._setReadonly(readonly, false);
+            this._setDisable(this.context.disable, false);
+            this.parameters = BarsaApi.Common.Util.TryGetValue(this.context, 'Setting.CustomUi.Parameters', null);
+            this.JsonExtraProp = BarsaApi.Common.Util.TryGetValue(this.context, 'Setting.JsonExtraProp', null);
+        }
+        this._addListener();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._removeListener();
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.focusControl) {
+            const elDom = this._el.nativeElement;
+            const focusableNodeList = elDom.querySelectorAll(' button, [href], input, select, textarea, [tabindex]:not([tabindex=”-1″])');
+            let focused = false;
+            focusableNodeList.forEach((el) => {
+                const tagName = el.tagName.toLocaleLowerCase();
+                if (!focused &&
+                    el.offsetWidth > 0 &&
+                    el.offsetHeight > 0 &&
+                    el.getAttribute('disabled') !== 'true' &&
+                    el.getAttribute('ng-reflect-disabled') !== 'true' &&
+                    !tagName.startsWith('fdp')) {
+                    el.focus();
+                    focused = true;
+                }
+            });
+        }
+    }
+    fireContextEvent(event, value, value1, value2) {
+        this.context.fireEvent(event, value, value1, value2);
+    }
+    _addListener() {
+        if (this.context && this.context.on) {
+            this.context.on({
+                ControlValueChanged: this._setValue.bind(this),
+                ControlDisableChanged: this._setDisable.bind(this),
+                ControlReadonlyChanged: this._setReadonly.bind(this),
+                ControlRefresh: this._setRefresh.bind(this)
+            });
+        }
+    }
+    _removeListener() {
+        if (this.context && this.context.un) {
+            this.context.un('ControlValueChanged', this._setValue);
+            this.context.un('ControlDisableChanged', this._setDisable);
+            this.context.un('ControlReadonlyChanged', this._setReadonly);
+            this.context.un('ControlRefresh', this._setRefresh);
+        }
+    }
+    _setValue(value) {
+        this.value = value;
+        this._valueChangedSource.next(value);
+        this._cdr.detectChanges();
+    }
+    _setRefresh(value) {
+        this._refreshSource.next(value);
+        this._cdr.detectChanges();
+    }
+    _setDisable(value, changeDetect = true) {
+        this._disableChangedSource.next(value);
+        if (changeDetect) {
+            this._cdr.detectChanges();
+        }
+    }
+    _setReadonly(value, changeDetect = true) {
+        this._readonlyChangedSource.next(value);
+        if (changeDetect) {
+            this._cdr.detectChanges();
+        }
+    }
+}
+FieldBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FieldBaseComponent, deps: [{ token: i1.PortalService }, { token: i2.BbbTranslatePipe }, { token: i2.PictureFieldSourcePipe }, { token: i2.NumeralPipe }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i3.ActivatedRoute }, { token: i4.DomSanitizer }, { token: DIALOG_SERVICE, optional: true }, { token: i1.UploadService, optional: true, self: true }, { token: i5.DateService, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+FieldBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: FieldBaseComponent, selector: "bnrc-field-base", inputs: { context: "context", focusControl: "focusControl", layoutInfo: "layoutInfo", value: "value", width: "width", height: "height", inlineEdit: "inlineEdit", id: "id" }, outputs: { valueChange: "valueChange", formmatedValue: "formmatedValue" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FieldBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-field-base',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PortalService }, { type: i2.BbbTranslatePipe }, { type: i2.PictureFieldSourcePipe }, { type: i2.NumeralPipe }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i3.ActivatedRoute }, { type: i4.DomSanitizer }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DIALOG_SERVICE]
+                }] }, { type: i1.UploadService, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: i5.DateService, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { context: [{
+                type: Input
+            }], focusControl: [{
+                type: Input
+            }], layoutInfo: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], inlineEdit: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], formmatedValue: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-base.js","sourceRoot":"","sources":["../../../../../projects/barsa-novin-ray-core/src/lib/abstract-classes/field-base.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,EACL,MAAM,EACN,YAAY,EACZ,SAAS,EAMT,uBAAuB,EAEvB,IAAI,EACJ,QAAQ,EACR,MAAM,EACT,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AAC3E,OAAO,EAAE,oBAAoB,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIlD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;;;;;;;AA6BvC,MAAM,OAAgB,kBAAmB,SAAQ,aAAa;IAyB1D,YACc,cAA6B,EAC7B,QAA0B,EAC1B,YAAoC,EACpC,YAAyB,EACzB,GAAe,EACf,IAAuB,EACvB,UAAqB,EACrB,eAA+B,EAC/B,aAA2B,EACS,cAAmB,EACnC,cAA6B,EAC7B,YAAyB;QAEvD,KAAK,EAAE,CAAC;QAbE,mBAAc,GAAd,cAAc,CAAe;QAC7B,aAAQ,GAAR,QAAQ,CAAkB;QAC1B,iBAAY,GAAZ,YAAY,CAAwB;QACpC,iBAAY,GAAZ,YAAY,CAAa;QACzB,QAAG,GAAH,GAAG,CAAY;QACf,SAAI,GAAJ,IAAI,CAAmB;QACvB,eAAU,GAAV,UAAU,CAAW;QACrB,oBAAe,GAAf,eAAe,CAAgB;QAC/B,kBAAa,GAAb,aAAa,CAAc;QACS,mBAAc,GAAd,cAAc,CAAK;QACnC,mBAAc,GAAd,cAAc,CAAe;QAC7B,iBAAY,GAAZ,YAAY,CAAa;QA5BjD,gBAAW,GAAG,IAAI,YAAY,EAAO,CAAC;QACtC,mBAAc,GAAG,IAAI,YAAY,EAAO,CAAC;QAU3C,mBAAc,GAAG,IAAI,OAAO,EAAO,CAAC;QACpC,wBAAmB,GAAG,IAAI,OAAO,EAAO,CAAC;QACzC,0BAAqB,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAC5D,2BAAsB,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QAiBjE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACrF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QACxF,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,qBAAqB;aACrC,YAAY,EAAE;aACd,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,sBAAsB;aACvC,YAAY,EAAE;aACd,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,kBAAkB,GAAG,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CACzE,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,OAAO,IAAI,QAAQ,CAAC,EACjD,oBAAoB,EAAE,CACzB,CAAC;QACF,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC;IAClB,CAAC;IAED,QAAQ;QACJ,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,IAAI,CAAC,OAAO,EAAE;YACd,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;YAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC;YACxC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACnC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC9C,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,6BAA6B,EAAE,IAAI,CAAC,CAAC;YACtG,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,uBAAuB,EAAE,IAAI,CAAC,CAAC;SACtG;QACD,IAAI,CAAC,YAAY,EAAE,CAAC;IACxB,CAAC;IACD,WAAW;QACP,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IACD,eAAe;QACX,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,aAA4B,CAAC;YACpD,MAAM,iBAAiB,GAA4B,KAAK,CAAC,gBAAgB,CACrE,2EAA2E,CAC9E,CAAC;YACF,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,iBAAiB,CAAC,OAAO,CAAC,CAAC,EAAe,EAAE,EAAE;gBAC1C,MAAM,OAAO,GAAW,EAAE,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;gBACvD,IACI,CAAC,OAAO;oBACR,EAAE,CAAC,WAAW,GAAG,CAAC;oBAClB,EAAE,CAAC,YAAY,GAAG,CAAC;oBACnB,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,MAAM;oBACtC,EAAE,CAAC,YAAY,CAAC,qBAAqB,CAAC,KAAK,MAAM;oBACjD,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,EAC5B;oBACE,EAAE,CAAC,KAAK,EAAE,CAAC;oBACX,OAAO,GAAG,IAAI,CAAC;iBAClB;YACL,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAED,gBAAgB,CAAC,KAAa,EAAE,KAAU,EAAE,MAAY,EAAE,MAAY;QAClE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IACS,YAAY;QAClB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE;YACjC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;gBACZ,mBAAmB,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;gBAC9C,qBAAqB,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;gBAClD,sBAAsB,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;gBACpD,cAAc,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;aAC9C,CAAC,CAAC;SACN;IACL,CAAC;IACS,eAAe;QACrB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE;YACjC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,qBAAqB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACvD,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,uBAAuB,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAC3D,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,wBAAwB,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;YAC7D,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,gBAAgB,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SACvD;IACL,CAAC;IACS,SAAS,CAAC,KAAK;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IACS,WAAW,CAAC,KAAK;QACvB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IACS,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;QAC5C,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,YAAY,EAAE;YACd,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;SAC7B;IACL,CAAC;IACS,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;QAC7C,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,IAAI,YAAY,EAAE;YACd,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;SAC7B;IACL,CAAC;;+GAzIiB,kBAAkB,8RAmCZ,cAAc;mGAnCpB,kBAAkB,uUAH1B,EAAE;2FAGM,kBAAkB;kBALvC,SAAS;mBAAC;oBACP,QAAQ,EAAE,iBAAiB;oBAC3B,QAAQ,EAAE,EAAE;oBACZ,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAClD;;0BAoCQ,QAAQ;;0BAAI,MAAM;2BAAC,cAAc;;0BACjC,IAAI;;0BAAI,QAAQ;;0BAChB,IAAI;;0BAAI,QAAQ;4CApCZ,OAAO;sBAAf,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,EAAE;sBAAV,KAAK;gBACI,WAAW;sBAApB,MAAM;gBACG,cAAc;sBAAvB,MAAM","sourcesContent":["import {\n    Input,\n    Output,\n    EventEmitter,\n    Component,\n    ChangeDetectorRef,\n    ElementRef,\n    OnInit,\n    OnDestroy,\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    Renderer2,\n    Self,\n    Optional,\n    Inject\n} from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { ActivatedRoute } from '@angular/router';\nimport { BehaviorSubject, combineLatest, Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, map, takeUntil } from 'rxjs/operators';\nimport { DIALOG_SERVICE } from '../../public-api';\n\nimport { BaseComponent } from '../base.component';\nimport { DateService } from '../date-services';\nimport { BbbTranslatePipe, NumeralPipe, PictureFieldSourcePipe } from '../pipes';\nimport { PortalService, UploadService } from '../services';\nimport { BarsaApi } from './barsa-api';\nimport { GeneralControlInfoModel } from './models';\n\nexport interface FieldSetting {\n    [key: string]: any;\n    ControlFieldCaption: string;\n    ControlFieldCaptionTranslated: string;\n    ControlFieldDefId: string;\n    ControlName: string;\n    RelatedFieldList: [];\n    Hide: boolean;\n    xtype: string;\n    LabelPosition: string;\n    IsMandatory: boolean;\n    IsVisible: boolean;\n    ShowLabel: boolean;\n    IsReadOnly: boolean;\n    IsEnabled: boolean;\n    IsBold: boolean;\n    IsAutomatic: boolean;\n    JsonExtraProp: any | null;\n    FieldIcon: string;\n    IsLtr: boolean;\n}\n@Component({\n    selector: 'bnrc-field-base',\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport abstract class FieldBaseComponent extends BaseComponent implements OnInit, OnDestroy, AfterViewInit {\n    @Input() context: any;\n    @Input() focusControl: boolean;\n    @Input() layoutInfo: any;\n    @Input() value: any;\n    @Input() width: number;\n    @Input() height: number;\n    @Input() inlineEdit: boolean;\n    @Input() id: string;\n    @Output() valueChange = new EventEmitter<any>();\n    @Output() formmatedValue = new EventEmitter<any>();\n    JsonExtraProp: any;\n    parameters: any;\n    Setting: GeneralControlInfoModel;\n    refresh$: Observable<any>;\n    value$: Observable<any>;\n    disable$: Observable<boolean>;\n    readonly$: Observable<boolean>;\n    disableOrReadonly$: Observable<boolean>;\n    el: any;\n    private _refreshSource = new Subject<any>();\n    private _valueChangedSource = new Subject<any>();\n    private _disableChangedSource = new BehaviorSubject<boolean>(false);\n    private _readonlyChangedSource = new BehaviorSubject<boolean>(false);\n\n    constructor(\n        protected _portalService: PortalService,\n        protected _bbbPipe: BbbTranslatePipe,\n        protected _picFieldSrc: PictureFieldSourcePipe,\n        protected _numeralPipe: NumeralPipe,\n        protected _el: ElementRef,\n        protected _cdr: ChangeDetectorRef,\n        protected _renderer2: Renderer2,\n        protected _activatedRoute: ActivatedRoute,\n        protected _domSanitizer: DomSanitizer,\n        @Optional() @Inject(DIALOG_SERVICE) protected _dialogService: any,\n        @Self() @Optional() protected _uploadService: UploadService,\n        @Self() @Optional() protected _dateService: DateService\n    ) {\n        super();\n        this.refresh$ = this._refreshSource.asObservable().pipe(takeUntil(this._onDestroy$));\n        this.value$ = this._valueChangedSource.asObservable().pipe(takeUntil(this._onDestroy$));\n        this.disable$ = this._disableChangedSource\n            .asObservable()\n            .pipe(takeUntil(this._onDestroy$), distinctUntilChanged());\n        this.readonly$ = this._readonlyChangedSource\n            .asObservable()\n            .pipe(takeUntil(this._onDestroy$), distinctUntilChanged());\n        this.disableOrReadonly$ = combineLatest([this.readonly$, this.disable$]).pipe(\n            map(([disable, readonly]) => disable || readonly),\n            distinctUntilChanged()\n        );\n        this.el = _el;\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        if (this.context) {\n            this.Setting = this.context ? this.context.Setting : null;\n            const readonly = this.context?.readOnly;\n            this._setReadonly(readonly, false);\n            this._setDisable(this.context.disable, false);\n            this.parameters = BarsaApi.Common.Util.TryGetValue(this.context, 'Setting.CustomUi.Parameters', null);\n            this.JsonExtraProp = BarsaApi.Common.Util.TryGetValue(this.context, 'Setting.JsonExtraProp', null);\n        }\n        this._addListener();\n    }\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._removeListener();\n    }\n    ngAfterViewInit(): void {\n        super.ngAfterViewInit();\n        if (this.focusControl) {\n            const elDom = this._el.nativeElement as HTMLElement;\n            const focusableNodeList: NodeListOf<HTMLElement> = elDom.querySelectorAll(\n                ' button, [href], input, select, textarea, [tabindex]:not([tabindex=”-1″])'\n            );\n            let focused = false;\n            focusableNodeList.forEach((el: HTMLElement) => {\n                const tagName: string = el.tagName.toLocaleLowerCase();\n                if (\n                    !focused &&\n                    el.offsetWidth > 0 &&\n                    el.offsetHeight > 0 &&\n                    el.getAttribute('disabled') !== 'true' &&\n                    el.getAttribute('ng-reflect-disabled') !== 'true' &&\n                    !tagName.startsWith('fdp')\n                ) {\n                    el.focus();\n                    focused = true;\n                }\n            });\n        }\n    }\n\n    fireContextEvent(event: string, value: any, value1?: any, value2?: any): void {\n        this.context.fireEvent(event, value, value1, value2);\n    }\n    protected _addListener(): void {\n        if (this.context && this.context.on) {\n            this.context.on({\n                ControlValueChanged: this._setValue.bind(this),\n                ControlDisableChanged: this._setDisable.bind(this),\n                ControlReadonlyChanged: this._setReadonly.bind(this),\n                ControlRefresh: this._setRefresh.bind(this)\n            });\n        }\n    }\n    protected _removeListener(): void {\n        if (this.context && this.context.un) {\n            this.context.un('ControlValueChanged', this._setValue);\n            this.context.un('ControlDisableChanged', this._setDisable);\n            this.context.un('ControlReadonlyChanged', this._setReadonly);\n            this.context.un('ControlRefresh', this._setRefresh);\n        }\n    }\n    protected _setValue(value): void {\n        this.value = value;\n        this._valueChangedSource.next(value);\n        this._cdr.detectChanges();\n    }\n    protected _setRefresh(value): void {\n        this._refreshSource.next(value);\n        this._cdr.detectChanges();\n    }\n    protected _setDisable(value, changeDetect = true): void {\n        this._disableChangedSource.next(value);\n        if (changeDetect) {\n            this._cdr.detectChanges();\n        }\n    }\n    protected _setReadonly(value, changeDetect = true): void {\n        this._readonlyChangedSource.next(value);\n        if (changeDetect) {\n            this._cdr.detectChanges();\n        }\n    }\n}\n"]}

package/esm2020/lib/abstract-classes/files-validation-helper.mjs

@@ -0,0 +1,71 @@
+import { of, throwError } from 'rxjs';
+import { concatMap, map, mergeMap, takeUntil, toArray } from 'rxjs/operators';
+import { BaseComponent } from '../base.component';
+import { formatBytes } from '../constants';
+import { BarsaApi } from './barsa-api';
+export class FilesValidationHelper extends BaseComponent {
+    constructor(maxFileCount, maxFileSizeKb, maxTotalFileSizeKb, bbbPipe) {
+        super();
+        this.bbbPipe = bbbPipe;
+        this.maxFileCount = Number(maxFileCount);
+        if (maxTotalFileSizeKb) {
+            this.maxTotalFileSize = Number(maxTotalFileSizeKb);
+            if (this.maxTotalFileSize > 0) {
+                this.maxTotalFileSize *= 1024;
+            }
+        }
+        if (maxFileSizeKb) {
+            this.maxFileSize = Number(maxFileSizeKb);
+            if (this.maxFileSize > 0) {
+                this.maxFileSize *= 1024;
+            }
+        }
+    }
+    validateFiles(validateFiles) {
+        return of(validateFiles).pipe(takeUntil(this._onDestroy$), map((files) => files), concatMap((files) => this._validateTotalSize(files)), concatMap((files) => this.filesCountError(files)), mergeMap((files) => files), concatMap((file) => this._validateSize(file)), toArray(), map((files) => files.filter((c) => !c.error).map((c) => c.file)), map((files) => this._validateMaxPictureCount(files)));
+    }
+    filesCountError(files) {
+        if (files.length > 0) {
+            return of(files);
+        }
+        return throwError('files count is 0');
+    }
+    _validateTotalSize(files) {
+        return new Promise((resolve) => {
+            const totalFileSize = files.reduce((accumulator, currFile) => accumulator + currFile.size, 0);
+            const uplaodTotalSizeTooBigText = this.bbbPipe?.transform('Uplaod_TotalSizeTooBig');
+            if (this.maxTotalFileSize > 0 && totalFileSize > this.maxTotalFileSize) {
+                const invalidFileSize = uplaodTotalSizeTooBigText
+                    ?.replace('{{{filesize}}}', formatBytes(totalFileSize, 2, 'MB'))
+                    .replace('{{maxFilesize}}', formatBytes(this.maxTotalFileSize, 2, 'MB'));
+                BarsaApi.Ul.MsgBox.Error(invalidFileSize, () => {
+                    resolve([]);
+                });
+            }
+            else {
+                resolve(files);
+            }
+        });
+    }
+    _validateSize(file) {
+        return new Promise((resolve, reject) => {
+            const uplaodFileTooBigText = this.bbbPipe?.transform('Uplaod_FileTooBig');
+            if (this.maxFileSize > 0 && file.size > this.maxFileSize) {
+                const invalidFileSize = uplaodFileTooBigText
+                    ?.replace('{{{filesize}}}', formatBytes(file.size, 2, 'MB'))
+                    .replace('{{maxFilesize}}', formatBytes(this.maxFileSize, 2, 'MB'));
+                BarsaApi.Ul.MsgBox.Error(invalidFileSize, () => {
+                    resolve({ file, error: invalidFileSize });
+                });
+            }
+            else {
+                resolve({ file });
+            }
+            reject();
+        });
+    }
+    _validateMaxPictureCount(files) {
+        return this.maxFileCount ? files.slice(0, this.maxFileCount) : files;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files-validation-helper.js","sourceRoot":"","sources":["../../../../../projects/barsa-novin-ray-core/src/lib/abstract-classes/files-validation-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, of, throwError } from 'rxjs';\nimport { concatMap, map, mergeMap, takeUntil, toArray } from 'rxjs/operators';\nimport { BaseComponent } from '../base.component';\nimport { formatBytes } from '../constants';\nimport { BarsaApi } from './barsa-api';\nimport { BbbTranslatePipe } from '../pipes/bbb-translate.pipe';\n\nexport class FilesValidationHelper extends BaseComponent {\n    maxFileCount: number;\n    maxFileSize: number;\n    maxTotalFileSize: number;\n\n    constructor(\n        maxFileCount: number,\n        maxFileSizeKb: number,\n        maxTotalFileSizeKb: number,\n        private bbbPipe?: BbbTranslatePipe\n    ) {\n        super();\n        this.maxFileCount = Number(maxFileCount);\n        if (maxTotalFileSizeKb) {\n            this.maxTotalFileSize = Number(maxTotalFileSizeKb);\n            if (this.maxTotalFileSize > 0) {\n                this.maxTotalFileSize *= 1024;\n            }\n        }\n        if (maxFileSizeKb) {\n            this.maxFileSize = Number(maxFileSizeKb);\n            if (this.maxFileSize > 0) {\n                this.maxFileSize *= 1024;\n            }\n        }\n    }\n\n    public validateFiles(validateFiles: File[]): Observable<File[]> {\n        return of(validateFiles).pipe(\n            takeUntil(this._onDestroy$),\n            map((files) => files),\n            concatMap((files) => this._validateTotalSize(files)),\n            concatMap((files) => this.filesCountError(files)),\n            mergeMap((files) => files),\n            concatMap((file) => this._validateSize(file)),\n            toArray(),\n            map((files) => files.filter((c) => !c.error).map((c) => c.file)),\n            map((files) => this._validateMaxPictureCount(files))\n        );\n    }\n\n    private filesCountError(files: File[]): Observable<File[]> {\n        if (files.length > 0) {\n            return of(files);\n        }\n        return throwError('files count is 0');\n    }\n\n    private _validateTotalSize(files: File[]): Promise<File[]> {\n        return new Promise<File[]>((resolve) => {\n            const totalFileSize = files.reduce((accumulator, currFile) => accumulator + currFile.size, 0);\n            const uplaodTotalSizeTooBigText = this.bbbPipe?.transform('Uplaod_TotalSizeTooBig');\n            if (this.maxTotalFileSize > 0 && totalFileSize > this.maxTotalFileSize) {\n                const invalidFileSize = uplaodTotalSizeTooBigText\n                    ?.replace('{{{filesize}}}', formatBytes(totalFileSize, 2, 'MB'))\n                    .replace('{{maxFilesize}}', formatBytes(this.maxTotalFileSize, 2, 'MB'));\n                BarsaApi.Ul.MsgBox.Error(invalidFileSize, () => {\n                    resolve([]);\n                });\n            } else {\n                resolve(files);\n            }\n        });\n    }\n\n    private _validateSize(file: File): Promise<{ file: File; error?: string }> {\n        return new Promise<{ file: File; error?: string }>((resolve, reject) => {\n            const uplaodFileTooBigText = this.bbbPipe?.transform('Uplaod_FileTooBig');\n            if (this.maxFileSize > 0 && file.size > this.maxFileSize) {\n                const invalidFileSize = uplaodFileTooBigText\n                    ?.replace('{{{filesize}}}', formatBytes(file.size, 2, 'MB'))\n                    .replace('{{maxFilesize}}', formatBytes(this.maxFileSize, 2, 'MB'));\n                BarsaApi.Ul.MsgBox.Error(invalidFileSize, () => {\n                    resolve({ file, error: invalidFileSize });\n                });\n            } else {\n                resolve({ file });\n            }\n            reject();\n        });\n    }\n\n    private _validateMaxPictureCount(files: File[]): File[] {\n        return this.maxFileCount ? files.slice(0, this.maxFileCount) : files;\n    }\n}\n"]}

package/esm2020/lib/abstract-classes/form-base.mjs

@@ -0,0 +1,101 @@
+import { Input, Component, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+import { filter, map, takeUntil, merge } from 'rxjs/operators';
+import { BaseComponent } from '../base.component';
+import { getDeviceIsMobile } from '../constants';
+import { BarsaApi } from './barsa-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/form-panel.service";
+export class FormBaseComponent extends BaseComponent {
+    constructor(_formPanelService) {
+        super();
+        this._formPanelService = _formPanelService;
+        this.formClose = new EventEmitter();
+        this._formPanelService.isSearchPanel$.subscribe((isSearchPanel) => {
+            this.isSearchPanel = isSearchPanel;
+        });
+        this.hideClose$ = this._formPanelService.hideClose$;
+        this.hideTitle$ = this._formPanelService.hideTitle$;
+        this.hidePin$ = this._formPanelService.hidePin$;
+        this.toolbarVisible$ = this._formPanelService.toolbarVisible$;
+        this.title$ = this._formPanelService.title$;
+        this.toolbarItems$ = this._formPanelService.toolbarItems$;
+        this.headerLayout$ = this._formPanelService.headerLayout$;
+        this.layout94$ = this._formPanelService.layout$;
+        this.maxContentWidth$ = this._formPanelService.maxContentWidth$;
+        this.formWidth$ = this._formPanelService.formWidth$;
+        this.headerSubtitle$ = this._formPanelService.headerSubtitle$;
+        this.avatar$ = this._formPanelService.avatar$;
+        this.workflowPanelUi$ = this._formPanelService.workflowPanelUi$;
+        this.view$ = this._formPanelService.view$;
+        this.mo$ = this._formPanelService.mo$;
+        this.fieldDict$ = this._formPanelService.fieldDict$;
+        this.isSimple$ = this._formPanelService.isSimpleForm$;
+        this.mask$ = this._formPanelService.mask$;
+        this.headerDescription$ = this._formPanelService.headerDescription$;
+        this.headerRemoveContentPadding$ = this._formPanelService.headerRemoveContentPadding$;
+        this._formPanelService.context$.pipe(takeUntil(this._onDestroy$)).subscribe();
+        this._formPanelService.view$.pipe(takeUntil(this._onDestroy$)).subscribe();
+    }
+    get forceClose$() {
+        return this._formPanelService.forceClose$;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this._formPanelService.context = this.context;
+        this.isMobile = getDeviceIsMobile();
+        this.listFieldUi = this.context._dictFieldUi;
+        this.isModal = this.context.Setting?.IsModal;
+        this.isSubForm = this.context.IsSubForm;
+        this.isFormReport = this.context.IsFormReport;
+        this._setParamters();
+        this.modernTabs$ = this.layout94$.pipe(filter((c) => c), map((layout94) => (this.layout94 = layout94)), 
+        /* eslint-disable */
+        merge(this._formPanelService.groupLayout$), map((_) => {
+            if (this.layout94.items[0].xtype !== 'Ly.LayoutTabPanel') {
+                return [];
+            }
+            const tabs = this.layout94.items[0].items;
+            return tabs.filter((c) => c.Visible !== false);
+        }));
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._formPanelService.destroy();
+    }
+    onClose() {
+        this.context.fireEvent('RequestForClose', this.context);
+    }
+    onToolbarClick(btn) {
+        this._formPanelService.toolbarClick(btn);
+    }
+    onWorkflowChoiceClick(wfChoice) {
+        this._formPanelService.wfChoice(wfChoice);
+    }
+    fieldChange(fieldName, value) {
+        const fieldUi = this.context._listFieldUi.find((c) => c.Setting.ControlName === fieldName);
+        fieldUi.value = value;
+        fieldUi.fireEvent('change', fieldUi);
+    }
+    searchClick() {
+        const fieldUi = this.context._listFieldUi.find((c) => c.originalXtype === 'Ui.SearchCommandInfoUi');
+        fieldUi.fireEvent(BarsaApi.Ul.FormPanelCtrlr.EventEnum.SearchClick, fieldUi);
+    }
+    _setParamters() {
+        this.parameters = BarsaApi.Common.Util.TryGetValue(this.context, 'Setting.View.CustomUi.Parameters', null);
+    }
+}
+FormBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormBaseComponent, deps: [{ token: i1.FormPanelService }], target: i0.ɵɵFactoryTarget.Component });
+FormBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: FormBaseComponent, selector: "bnrc-form-base", inputs: { context: "context" }, outputs: { formClose: "formClose" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-form-base',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormPanelService }]; }, propDecorators: { context: [{
+                type: Input
+            }], formClose: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-base.js","sourceRoot":"","sources":["../../../../../projects/barsa-novin-ray-core/src/lib/abstract-classes/form-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Component, Output, EventEmitter, OnInit, OnDestroy, ChangeDetectionStrategy } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { filter, map, takeUntil, merge } from 'rxjs/operators';\n\nimport { BaseComponent } from '../base.component';\nimport { getDeviceIsMobile } from '../constants';\nimport { FormPanelService } from '../services/form-panel.service';\nimport { BarsaApi } from './barsa-api';\nimport { FormSetting, FormViewSetting, IHeaderLayout, LayoutSetting, MetaobjectDataModel } from './models';\n\n@Component({\n    selector: 'bnrc-form-base',\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FormBaseComponent extends BaseComponent implements OnInit, OnDestroy {\n    @Input() context: {\n        [key: string]: any;\n        config: any;\n        Setting: FormSetting;\n    };\n    @Output() formClose = new EventEmitter();\n    listFieldUi: any;\n    isWizard: boolean;\n    parameters: MetaobjectDataModel;\n    isMobile: boolean;\n\n    toolbarVisible$: Observable<boolean>;\n    hideClose$: Observable<boolean>;\n    hideTitle$: Observable<boolean>;\n    hidePin$: Observable<boolean>;\n    title$: Observable<string>;\n    toolbarItems$: Observable<any[]>;\n    headerLayout$: Observable<IHeaderLayout | null>;\n    layout94$: Observable<any>;\n    layout94: any;\n    maxContentWidth$: Observable<string>;\n    formWidth$: Observable<string>;\n    headerDescription$: Observable<string>;\n    headerRemoveContentPadding$: Observable<boolean>;\n    headerSubtitle$: Observable<string>;\n    avatar$: Observable<any>;\n    workflowPanelUi$: Observable<any>;\n    view$: Observable<FormViewSetting>;\n    mo$: Observable<MetaobjectDataModel | null>;\n    isSimple$: Observable<boolean>;\n    fieldDict$: Observable<{ [key: string]: string } | undefined>;\n    mask$: Observable<boolean>;\n    isSearchPanel: boolean;\n    isModal: boolean;\n    isSubForm: boolean;\n    modernTabs$: Observable<LayoutSetting[]>;\n    isFormReport: boolean;\n    constructor(protected _formPanelService: FormPanelService) {\n        super();\n        this._formPanelService.isSearchPanel$.subscribe((isSearchPanel) => {\n            this.isSearchPanel = isSearchPanel;\n        });\n        this.hideClose$ = this._formPanelService.hideClose$;\n        this.hideTitle$ = this._formPanelService.hideTitle$;\n        this.hidePin$ = this._formPanelService.hidePin$;\n        this.toolbarVisible$ = this._formPanelService.toolbarVisible$;\n        this.title$ = this._formPanelService.title$;\n        this.toolbarItems$ = this._formPanelService.toolbarItems$;\n        this.headerLayout$ = this._formPanelService.headerLayout$;\n        this.layout94$ = this._formPanelService.layout$;\n        this.maxContentWidth$ = this._formPanelService.maxContentWidth$;\n        this.formWidth$ = this._formPanelService.formWidth$;\n        this.headerSubtitle$ = this._formPanelService.headerSubtitle$;\n        this.avatar$ = this._formPanelService.avatar$;\n        this.workflowPanelUi$ = this._formPanelService.workflowPanelUi$;\n        this.view$ = this._formPanelService.view$;\n        this.mo$ = this._formPanelService.mo$;\n        this.fieldDict$ = this._formPanelService.fieldDict$;\n        this.isSimple$ = this._formPanelService.isSimpleForm$;\n        this.mask$ = this._formPanelService.mask$;\n        this.headerDescription$ = this._formPanelService.headerDescription$;\n        this.headerRemoveContentPadding$ = this._formPanelService.headerRemoveContentPadding$;\n        this._formPanelService.context$.pipe(takeUntil(this._onDestroy$)).subscribe();\n        this._formPanelService.view$.pipe(takeUntil(this._onDestroy$)).subscribe();\n    }\n    get forceClose$(): Observable<void> {\n        return this._formPanelService.forceClose$;\n    }\n\n    ngOnInit(): void {\n        super.ngOnInit();\n        this._formPanelService.context = this.context;\n        this.isMobile = getDeviceIsMobile();\n        this.listFieldUi = this.context._dictFieldUi;\n\n        this.isModal = this.context.Setting?.IsModal;\n        this.isSubForm = this.context.IsSubForm;\n        this.isFormReport = this.context.IsFormReport;\n        this._setParamters();\n        this.modernTabs$ = this.layout94$.pipe(\n            filter((c) => c),\n            map((layout94) => (this.layout94 = layout94)),\n            /* eslint-disable */\n            merge(this._formPanelService.groupLayout$),\n            map((_) => {\n                if (this.layout94.items[0].xtype !== 'Ly.LayoutTabPanel') {\n                    return [];\n                }\n                const tabs: LayoutSetting[] = this.layout94.items[0].items;\n                return tabs.filter((c) => c.Visible !== false);\n            })\n        );\n    }\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._formPanelService.destroy();\n    }\n    onClose(): void {\n        this.context.fireEvent('RequestForClose', this.context);\n    }\n    onToolbarClick(btn): void {\n        this._formPanelService.toolbarClick(btn);\n    }\n    onWorkflowChoiceClick(wfChoice): void {\n        this._formPanelService.wfChoice(wfChoice);\n    }\n    fieldChange(fieldName, value): void {\n        const fieldUi = this.context._listFieldUi.find((c) => c.Setting.ControlName === fieldName);\n        fieldUi.value = value;\n        fieldUi.fireEvent('change', fieldUi);\n    }\n    searchClick(): void {\n        const fieldUi = this.context._listFieldUi.find((c) => c.originalXtype === 'Ui.SearchCommandInfoUi');\n\n        fieldUi.fireEvent(BarsaApi.Ul.FormPanelCtrlr.EventEnum.SearchClick, fieldUi);\n    }\n    private _setParamters(): void {\n        this.parameters = BarsaApi.Common.Util.TryGetValue(this.context, 'Setting.View.CustomUi.Parameters', null);\n    }\n}\n"]}

package/esm2020/lib/abstract-classes/form-props.base.mjs

@@ -0,0 +1,79 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { BaseComponent } from '../base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../pipes";
+import * as i2 from "../services";
+import * as i3 from "@angular/platform-browser";
+export class FormPropsBaseComponent extends BaseComponent {
+    constructor(_controlUiPipe, _formPanelService, _sanitizer, _cdr, _renderer2, _vcr, _factoryResolver) {
+        super();
+        this._controlUiPipe = _controlUiPipe;
+        this._formPanelService = _formPanelService;
+        this._sanitizer = _sanitizer;
+        this._cdr = _cdr;
+        this._renderer2 = _renderer2;
+        this._vcr = _vcr;
+        this._factoryResolver = _factoryResolver;
+    }
+    ngOnInit() {
+        // this.mo = this._formPanelService.mo;
+        super.ngOnInit();
+    }
+}
+FormPropsBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormPropsBaseComponent, deps: [{ token: i1.ControlUiPipe }, { token: i2.FormPanelService }, { token: i3.DomSanitizer }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Component });
+FormPropsBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: FormPropsBaseComponent, selector: "bnrc-form-props-base", inputs: { breadCrumbs: "breadCrumbs", toolbarVisible: "toolbarVisible", toolbarItems: "toolbarItems", layoutActions: "layoutActions", layout94: "layout94", settings: "settings", workflowPanelUi: "workflowPanelUi", title: "title", subtitle: "subtitle", description: "description", facetList: "facetList", removeHeaderBorder: "removeHeaderBorder", removeContentPadding: "removeContentPadding", isMobile: "isMobile", avatar: "avatar", rtl: "rtl", mask: "mask", fieldDict: "fieldDict", contentDensity: "contentDensity", deviceSize: "deviceSize", dirValue: "dirValue", modernTabs: "modernTabs", mo: "mo" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormPropsBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-form-props-base',
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ControlUiPipe }, { type: i2.FormPanelService }, { type: i3.DomSanitizer }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.ComponentFactoryResolver }]; }, propDecorators: { breadCrumbs: [{
+                type: Input
+            }], toolbarVisible: [{
+                type: Input
+            }], toolbarItems: [{
+                type: Input
+            }], layoutActions: [{
+                type: Input
+            }], layout94: [{
+                type: Input
+            }], settings: [{
+                type: Input
+            }], workflowPanelUi: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], subtitle: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], facetList: [{
+                type: Input
+            }], removeHeaderBorder: [{
+                type: Input
+            }], removeContentPadding: [{
+                type: Input
+            }], isMobile: [{
+                type: Input
+            }], avatar: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], mask: [{
+                type: Input
+            }], fieldDict: [{
+                type: Input
+            }], contentDensity: [{
+                type: Input
+            }], deviceSize: [{
+                type: Input
+            }], dirValue: [{
+                type: Input
+            }], modernTabs: [{
+                type: Input
+            }], mo: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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