@sumaris-net/ngx-components 2.6.17 → 4.0.0-rc1

package/esm2022/src/app/shared/material/material.testing.module.mjs

@@ -0,0 +1,210 @@
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { SharedTestsPage } from '../testing/tests.page';
+import { SharedMaterialModule } from './material.module';
+import { IonicModule } from '@ionic/angular';
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TranslateModule } from '@ngx-translate/core';
+import { DateTimeTestPage } from './datetime/testing/mat-date-time.test';
+import { DateTestPage } from './datetime/testing/mat-date.test';
+import { SharedPipesModule } from '../pipes/pipes.module';
+import { ObservableTestPage } from '../testing/observable.test';
+import { DateShortTestPage } from './datetime/testing/mat-dateshort.test';
+import { AutocompleteTestPage } from './autocomplete/testing/autocomplete.test';
+import { LatLongTestPage } from './latlong/testing/latlong.test';
+import { NumpadTestPage } from './numpad/testing/numpad.test';
+import { SwipeTestPage } from './swipe/testing/swipe.test';
+import { ChipsTestPage } from './chips/testing/chips.test';
+import { MatBadgeTestPage } from './badge/badge.test';
+import { SharedBadgeModule } from './badge/badge.module';
+import { DurationTestPage } from './duration/testing/mat-duration.test';
+import { MatCommonTestPage } from './testing/common.test';
+import { BooleanTestPage } from './boolean/testing/boolean.test.page';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/router";
+export const SHARED_MATERIAL_TESTING_PAGES = [
+    { label: 'Shared Material components', divider: true },
+    { label: 'Common field', page: '/testing/shared/common' },
+    { label: 'Date/Time field', page: '/testing/shared/datetime' },
+    { label: 'Date field', page: '/testing/shared/date' },
+    { label: 'Date short field', page: '/testing/shared/dateshort' },
+    { label: 'Duration field', page: '/testing/shared/duration' },
+    { label: 'Autocomplete field', page: '/testing/shared/autocomplete' },
+    { label: 'Boolean field', page: '/testing/shared/boolean' },
+    { label: 'Lat/Long field', page: '/testing/shared/latlong' },
+    { label: 'Numeric pad component', page: '/testing/shared/numpad' },
+    { label: 'Swipe component', page: '/testing/shared/swipe' },
+    { label: 'Chips component', page: '/testing/shared/chips' },
+    { label: 'Shared directives', divider: true },
+    { label: 'Badge directive', page: '/testing/shared/badge' },
+    { label: 'Shared utils', divider: true },
+    { label: 'Observable', page: '/testing/shared/observable' }
+];
+const routes = [
+    {
+        path: '',
+        pathMatch: 'full',
+        component: SharedTestsPage
+    },
+    {
+        path: 'common',
+        pathMatch: 'full',
+        component: MatCommonTestPage
+    },
+    {
+        path: 'datetime',
+        pathMatch: 'full',
+        component: DateTimeTestPage
+    },
+    {
+        path: 'date',
+        pathMatch: 'full',
+        component: DateTestPage
+    },
+    {
+        path: 'dateshort',
+        pathMatch: 'full',
+        component: DateShortTestPage
+    },
+    {
+        path: 'duration',
+        pathMatch: 'full',
+        component: DurationTestPage
+    },
+    {
+        path: 'autocomplete',
+        pathMatch: 'full',
+        component: AutocompleteTestPage
+    },
+    {
+        path: 'boolean',
+        pathMatch: 'full',
+        component: BooleanTestPage
+    },
+    {
+        path: 'latlong',
+        pathMatch: 'full',
+        component: LatLongTestPage
+    },
+    {
+        path: 'numpad',
+        pathMatch: 'full',
+        component: NumpadTestPage
+    },
+    {
+        path: 'swipe',
+        pathMatch: 'full',
+        component: SwipeTestPage
+    },
+    {
+        path: 'chips',
+        pathMatch: 'full',
+        component: ChipsTestPage
+    },
+    {
+        path: 'badge',
+        pathMatch: 'full',
+        component: MatBadgeTestPage
+    },
+    {
+        path: 'observable',
+        pathMatch: 'full',
+        component: ObservableTestPage
+    },
+];
+export class MaterialTestingModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MaterialTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: MaterialTestingModule, declarations: [MatCommonTestPage,
+            DateTimeTestPage,
+            DateTestPage,
+            DateShortTestPage,
+            DurationTestPage,
+            AutocompleteTestPage,
+            BooleanTestPage,
+            LatLongTestPage,
+            NumpadTestPage,
+            SwipeTestPage,
+            ChipsTestPage,
+            MatBadgeTestPage,
+            ObservableTestPage], imports: [CommonModule,
+            IonicModule,
+            ReactiveFormsModule,
+            SharedMaterialModule, i1.TranslateModule, i2.RouterModule, SharedPipesModule,
+            SharedBadgeModule,
+            FormsModule], exports: [SharedMaterialModule,
+            RouterModule,
+            MatCommonTestPage,
+            DateTimeTestPage,
+            DateTestPage,
+            DateShortTestPage,
+            DurationTestPage,
+            AutocompleteTestPage,
+            BooleanTestPage,
+            LatLongTestPage,
+            NumpadTestPage,
+            SwipeTestPage,
+            ChipsTestPage,
+            MatBadgeTestPage,
+            ObservableTestPage] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MaterialTestingModule, imports: [CommonModule,
+            IonicModule,
+            ReactiveFormsModule,
+            SharedMaterialModule,
+            TranslateModule.forChild(),
+            RouterModule.forChild(routes),
+            SharedPipesModule,
+            SharedBadgeModule,
+            FormsModule, SharedMaterialModule,
+            RouterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MaterialTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        IonicModule,
+                        ReactiveFormsModule,
+                        SharedMaterialModule,
+                        TranslateModule.forChild(),
+                        RouterModule.forChild(routes),
+                        SharedPipesModule,
+                        SharedBadgeModule,
+                        FormsModule,
+                    ],
+                    declarations: [
+                        MatCommonTestPage,
+                        DateTimeTestPage,
+                        DateTestPage,
+                        DateShortTestPage,
+                        DurationTestPage,
+                        AutocompleteTestPage,
+                        BooleanTestPage,
+                        LatLongTestPage,
+                        NumpadTestPage,
+                        SwipeTestPage,
+                        ChipsTestPage,
+                        MatBadgeTestPage,
+                        ObservableTestPage
+                    ],
+                    exports: [
+                        SharedMaterialModule,
+                        RouterModule,
+                        MatCommonTestPage,
+                        DateTimeTestPage,
+                        DateTestPage,
+                        DateShortTestPage,
+                        DurationTestPage,
+                        AutocompleteTestPage,
+                        BooleanTestPage,
+                        LatLongTestPage,
+                        NumpadTestPage,
+                        SwipeTestPage,
+                        ChipsTestPage,
+                        MatBadgeTestPage,
+                        ObservableTestPage
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.testing.module.js","sourceRoot":"","sources":["../../../../../../src/app/shared/material/material.testing.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,YAAY,EAAS,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAC,eAAe,EAAc,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAC,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAC,WAAW,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAC,gBAAgB,EAAC,MAAM,uCAAuC,CAAC;AACvE,OAAO,EAAC,YAAY,EAAC,MAAM,kCAAkC,CAAC;AAC9D,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAC,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAC,iBAAiB,EAAC,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAC,oBAAoB,EAAC,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAC,eAAe,EAAC,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAC,gBAAgB,EAAC,MAAM,sCAAsC,CAAC;AACtE,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAC,eAAe,EAAC,MAAM,qCAAqC,CAAC;;;;AAEpE,MAAM,CAAC,MAAM,6BAA6B,GAAkB;IAC1D,EAAC,KAAK,EAAE,4BAA4B,EAAE,OAAO,EAAE,IAAI,EAAC;IACpD,EAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,wBAAwB,EAAC;IACvD,EAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,0BAA0B,EAAC;IAC5D,EAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,sBAAsB,EAAC;IACnD,EAAC,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,2BAA2B,EAAC;IAC9D,EAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,0BAA0B,EAAC;IAC3D,EAAC,KAAK,EAAE,oBAAoB,EAAE,IAAI,EAAE,8BAA8B,EAAC;IACnE,EAAC,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,yBAAyB,EAAC;IACzD,EAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,yBAAyB,EAAC;IAC1D,EAAC,KAAK,EAAE,uBAAuB,EAAE,IAAI,EAAE,wBAAwB,EAAC;IAEhE,EAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,uBAAuB,EAAC;IACzD,EAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,uBAAuB,EAAC;IAEzD,EAAC,KAAK,EAAE,mBAAmB,EAAE,OAAO,EAAE,IAAI,EAAC;IAC3C,EAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,uBAAuB,EAAC;IAEzD,EAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,IAAI,EAAC;IACtC,EAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,4BAA4B,EAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,GAAW;IACrB;QACE,IAAI,EAAE,EAAE;QACR,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,eAAe;KAC3B;IACD;QACE,IAAI,EAAE,QAAQ;QACd,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,iBAAiB;KAC7B;IACD;QACE,IAAI,EAAE,UAAU;QAChB,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,gBAAgB;KAC5B;IACD;QACE,IAAI,EAAE,MAAM;QACZ,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,YAAY;KACxB;IACD;QACE,IAAI,EAAE,WAAW;QACjB,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,iBAAiB;KAC7B;IACD;QACE,IAAI,EAAE,UAAU;QAChB,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,gBAAgB;KAC5B;IACD;QACE,IAAI,EAAE,cAAc;QACpB,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,oBAAoB;KAChC;IACD;QACE,IAAI,EAAE,SAAS;QACf,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,eAAe;KAC3B;IACD;QACE,IAAI,EAAE,SAAS;QACf,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,eAAe;KAC3B;IACD;QACE,IAAI,EAAE,QAAQ;QACd,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,cAAc;KAC1B;IACD;QACE,IAAI,EAAE,OAAO;QACb,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,aAAa;KACzB;IACD;QACE,IAAI,EAAE,OAAO;QACb,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,aAAa;KACzB;IACD;QACE,IAAI,EAAE,OAAO;QACb,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,gBAAgB;KAC5B;IACD;QACE,IAAI,EAAE,YAAY;QAClB,SAAS,EAAE,MAAM;QACjB,SAAS,EAAE,kBAAkB;KAC9B;CACF,CAAC;AA+CF,MAAM,OAAO,qBAAqB;wGAArB,qBAAqB;yGAArB,qBAAqB,iBAhC9B,iBAAiB;YACjB,gBAAgB;YAChB,YAAY;YACZ,iBAAiB;YACjB,gBAAgB;YAChB,oBAAoB;YACpB,eAAe;YACf,eAAe;YACf,cAAc;YACd,aAAa;YACb,aAAa;YACb,gBAAgB;YAChB,kBAAkB,aAvBlB,YAAY;YACZ,WAAW;YACX,mBAAmB;YACnB,oBAAoB,uCAGpB,iBAAiB;YACjB,iBAAiB;YACjB,WAAW,aAkBX,oBAAoB;YACpB,YAAY;YACZ,iBAAiB;YACjB,gBAAgB;YAChB,YAAY;YACZ,iBAAiB;YACjB,gBAAgB;YAChB,oBAAoB;YACpB,eAAe;YACf,eAAe;YACf,cAAc;YACd,aAAa;YACb,aAAa;YACb,gBAAgB;YAChB,kBAAkB;yGAGT,qBAAqB,YA3C9B,YAAY;YACZ,WAAW;YACX,mBAAmB;YACnB,oBAAoB;YACpB,eAAe,CAAC,QAAQ,EAAE;YAC1B,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC;YAC7B,iBAAiB;YACjB,iBAAiB;YACjB,WAAW,EAkBX,oBAAoB;YACpB,YAAY;;4FAgBH,qBAAqB;kBA7CjC,QAAQ;mBAAC;oBACR,OAAO,EAAE;wBACP,YAAY;wBACZ,WAAW;wBACX,mBAAmB;wBACnB,oBAAoB;wBACpB,eAAe,CAAC,QAAQ,EAAE;wBAC1B,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC;wBAC7B,iBAAiB;wBACjB,iBAAiB;wBACjB,WAAW;qBACZ;oBACD,YAAY,EAAE;wBACZ,iBAAiB;wBACjB,gBAAgB;wBAChB,YAAY;wBACZ,iBAAiB;wBACjB,gBAAgB;wBAChB,oBAAoB;wBACpB,eAAe;wBACf,eAAe;wBACf,cAAc;wBACd,aAAa;wBACb,aAAa;wBACb,gBAAgB;wBAChB,kBAAkB;qBACnB;oBACD,OAAO,EAAE;wBACP,oBAAoB;wBACpB,YAAY;wBACZ,iBAAiB;wBACjB,gBAAgB;wBAChB,YAAY;wBACZ,iBAAiB;wBACjB,gBAAgB;wBAChB,oBAAoB;wBACpB,eAAe;wBACf,eAAe;wBACf,cAAc;wBACd,aAAa;wBACb,aAAa;wBACb,gBAAgB;wBAChB,kBAAkB;qBACnB;iBACF","sourcesContent":["import {NgModule} from '@angular/core';\nimport {RouterModule, Routes} from '@angular/router';\nimport {SharedTestsPage, TestingPage} from '../testing/tests.page';\nimport {SharedMaterialModule} from './material.module';\nimport {IonicModule} from '@ionic/angular';\nimport {CommonModule} from '@angular/common';\nimport {FormsModule, ReactiveFormsModule} from '@angular/forms';\nimport {TranslateModule} from '@ngx-translate/core';\nimport {DateTimeTestPage} from './datetime/testing/mat-date-time.test';\nimport {DateTestPage} from './datetime/testing/mat-date.test';\nimport {SharedPipesModule} from '../pipes/pipes.module';\nimport {ObservableTestPage} from '../testing/observable.test';\nimport {DateShortTestPage} from './datetime/testing/mat-dateshort.test';\nimport {AutocompleteTestPage} from './autocomplete/testing/autocomplete.test';\nimport {LatLongTestPage} from './latlong/testing/latlong.test';\nimport {NumpadTestPage} from './numpad/testing/numpad.test';\nimport {SwipeTestPage} from './swipe/testing/swipe.test';\nimport {ChipsTestPage} from './chips/testing/chips.test';\nimport {MatBadgeTestPage} from './badge/badge.test';\nimport {SharedBadgeModule} from './badge/badge.module';\nimport {DurationTestPage} from './duration/testing/mat-duration.test';\nimport {MatCommonTestPage} from './testing/common.test';\nimport {BooleanTestPage} from './boolean/testing/boolean.test.page';\n\nexport const SHARED_MATERIAL_TESTING_PAGES: TestingPage[] = [\n  {label: 'Shared Material components', divider: true},\n  {label: 'Common field', page: '/testing/shared/common'},\n  {label: 'Date/Time field', page: '/testing/shared/datetime'},\n  {label: 'Date field', page: '/testing/shared/date'},\n  {label: 'Date short field', page: '/testing/shared/dateshort'},\n  {label: 'Duration field', page: '/testing/shared/duration'},\n  {label: 'Autocomplete field', page: '/testing/shared/autocomplete'},\n  {label: 'Boolean field', page: '/testing/shared/boolean'},\n  {label: 'Lat/Long field', page: '/testing/shared/latlong'},\n  {label: 'Numeric pad component', page: '/testing/shared/numpad'},\n\n  {label: 'Swipe component', page: '/testing/shared/swipe'},\n  {label: 'Chips component', page: '/testing/shared/chips'},\n\n  {label: 'Shared directives', divider: true},\n  {label: 'Badge directive', page: '/testing/shared/badge'},\n\n  {label: 'Shared utils', divider: true},\n  {label: 'Observable', page: '/testing/shared/observable'}\n];\n\nconst routes: Routes = [\n  {\n    path: '',\n    pathMatch: 'full',\n    component: SharedTestsPage\n  },\n  {\n    path: 'common',\n    pathMatch: 'full',\n    component: MatCommonTestPage\n  },\n  {\n    path: 'datetime',\n    pathMatch: 'full',\n    component: DateTimeTestPage\n  },\n  {\n    path: 'date',\n    pathMatch: 'full',\n    component: DateTestPage\n  },\n  {\n    path: 'dateshort',\n    pathMatch: 'full',\n    component: DateShortTestPage\n  },\n  {\n    path: 'duration',\n    pathMatch: 'full',\n    component: DurationTestPage\n  },\n  {\n    path: 'autocomplete',\n    pathMatch: 'full',\n    component: AutocompleteTestPage\n  },\n  {\n    path: 'boolean',\n    pathMatch: 'full',\n    component: BooleanTestPage\n  },\n  {\n    path: 'latlong',\n    pathMatch: 'full',\n    component: LatLongTestPage\n  },\n  {\n    path: 'numpad',\n    pathMatch: 'full',\n    component: NumpadTestPage\n  },\n  {\n    path: 'swipe',\n    pathMatch: 'full',\n    component: SwipeTestPage\n  },\n  {\n    path: 'chips',\n    pathMatch: 'full',\n    component: ChipsTestPage\n  },\n  {\n    path: 'badge',\n    pathMatch: 'full',\n    component: MatBadgeTestPage\n  },\n  {\n    path: 'observable',\n    pathMatch: 'full',\n    component: ObservableTestPage\n  },\n];\n\n@NgModule({\n  imports: [\n    CommonModule,\n    IonicModule,\n    ReactiveFormsModule,\n    SharedMaterialModule,\n    TranslateModule.forChild(),\n    RouterModule.forChild(routes),\n    SharedPipesModule,\n    SharedBadgeModule,\n    FormsModule,\n  ],\n  declarations: [\n    MatCommonTestPage,\n    DateTimeTestPage,\n    DateTestPage,\n    DateShortTestPage,\n    DurationTestPage,\n    AutocompleteTestPage,\n    BooleanTestPage,\n    LatLongTestPage,\n    NumpadTestPage,\n    SwipeTestPage,\n    ChipsTestPage,\n    MatBadgeTestPage,\n    ObservableTestPage\n  ],\n  exports: [\n    SharedMaterialModule,\n    RouterModule,\n    MatCommonTestPage,\n    DateTimeTestPage,\n    DateTestPage,\n    DateShortTestPage,\n    DurationTestPage,\n    AutocompleteTestPage,\n    BooleanTestPage,\n    LatLongTestPage,\n    NumpadTestPage,\n    SwipeTestPage,\n    ChipsTestPage,\n    MatBadgeTestPage,\n    ObservableTestPage\n  ]\n})\nexport class MaterialTestingModule {\n}\n"]}

package/esm2022/src/app/shared/material/numpad/numpad.append-to-input.directive.mjs

@@ -0,0 +1,104 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AppendToInputDirective {
+    renderer;
+    inputElement;
+    _directionY;
+    _directionX;
+    _inputCords;
+    element;
+    constructor(elementRef, renderer) {
+        this.renderer = renderer;
+        this.element = elementRef.nativeElement;
+    }
+    get inputCords() {
+        return this.inputElement.getBoundingClientRect();
+    }
+    get directionY() {
+        const height = this.element.offsetHeight;
+        const { bottom, top } = this._inputCords;
+        const isElementFit = (window && window.innerHeight) - bottom < height;
+        const isTop = isElementFit && top > height;
+        const isCenter = isElementFit && top < height;
+        if (isTop) {
+            return 'top';
+        }
+        else if (isCenter) {
+            return 'center';
+        }
+        return 'bottom';
+    }
+    get directionX() {
+        const width = this.element.offsetWidth;
+        const { left, right } = this._inputCords;
+        const isElementFit = (window && window.innerWidth) - left < width;
+        const isEnd = isElementFit && right > width;
+        const isCenter = isElementFit && right < width;
+        if (isEnd) {
+            return 'end';
+        }
+        else if (isCenter) {
+            return 'center';
+        }
+        return 'start';
+    }
+    ngAfterViewInit() {
+        this._inputCords = this.inputCords;
+        this._directionY = this.directionY;
+        this._directionX = this.directionX;
+        this.append();
+    }
+    changePosition() {
+        const { left, right, bottom, top } = this.inputCords;
+        const x = this.defineElementYByDirection(left, right);
+        const y = this.defineElementYByDirection(top, bottom);
+        this.setStyle('left', `${x}px`);
+        this.setStyle('top', `${y}px`);
+    }
+    append() {
+        const { left, right, bottom, top } = this._inputCords;
+        const x = this.defineElementXByDirection(left, right);
+        const y = this.defineElementYByDirection(top, bottom);
+        this.setStyle('position', 'fixed');
+        this.setStyle('left', `${x}px`);
+        this.setStyle('top', `${y}px`);
+    }
+    setStyle(style, value) {
+        this.renderer.setStyle(this.element, style, value);
+    }
+    defineElementYByDirection(inputTop, inputBottom) {
+        if (this._directionY === 'top') {
+            return inputTop - this.element.offsetHeight;
+        }
+        else if (this._directionY === 'center') {
+            return inputTop - (this.element.offsetHeight / 2);
+        }
+        return inputBottom;
+    }
+    defineElementXByDirection(inputLeft, inputRight) {
+        // DEBUG
+        //console.log("defineElementXByDirection ", inputLeft, inputRight);
+        if (this._directionX === 'end') {
+            return inputRight - this.element.offsetWidth;
+        }
+        else if (this._directionX === 'center') {
+            return inputRight - (this.element.offsetWidth / 2);
+        }
+        return inputLeft;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppendToInputDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AppendToInputDirective, selector: "[appendNumpadToInput]", inputs: { inputElement: ["appendNumpadToInput", "inputElement"] }, host: { listeners: { "window:scroll": "changePosition()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AppendToInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appendNumpadToInput]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { inputElement: [{
+                type: Input,
+                args: ['appendNumpadToInput']
+            }], changePosition: [{
+                type: HostListener,
+                args: ['window:scroll']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"numpad.append-to-input.directive.js","sourceRoot":"","sources":["../../../../../../../src/app/shared/material/numpad/numpad.append-to-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, Directive, ElementRef, HostListener, Input, Renderer2} from '@angular/core';\n\ntype TimepickerDirectionY = 'top' | 'center' | 'bottom';\ntype TimepickerDirectionX = 'start' | 'center' | 'end';\n\n@Directive({\n    selector: '[appendNumpadToInput]'\n})\nexport class AppendToInputDirective implements AfterViewInit {\n\n    @Input('appendNumpadToInput') inputElement: any;\n\n    private _directionY: TimepickerDirectionY;\n    private _directionX: TimepickerDirectionX;\n    private _inputCords: ClientRect;\n    private readonly element: HTMLElement;\n\n    constructor(elementRef: ElementRef<HTMLElement>,\n                private renderer: Renderer2) {\n        this.element = elementRef.nativeElement;\n    }\n\n    private get inputCords(): ClientRect {\n        return this.inputElement.getBoundingClientRect();\n    }\n\n    private get directionY(): TimepickerDirectionY {\n        const height = this.element.offsetHeight;\n        const {bottom, top} = this._inputCords;\n        const isElementFit = (window && window.innerHeight) - bottom < height;\n        const isTop = isElementFit && top > height;\n        const isCenter = isElementFit && top < height;\n\n        if (isTop) {\n            return 'top';\n        } else if (isCenter) {\n            return 'center';\n        }\n        return 'bottom';\n    }\n\n  private get directionX(): TimepickerDirectionX {\n    const width = this.element.offsetWidth;\n    const {left, right} = this._inputCords;\n    const isElementFit = (window && window.innerWidth) - left < width;\n    const isEnd = isElementFit && right > width;\n    const isCenter = isElementFit && right < width;\n\n    if (isEnd) {\n      return 'end';\n    } else if (isCenter) {\n      return 'center';\n    }\n    return 'start';\n  }\n\n    ngAfterViewInit(): void {\n        this._inputCords = this.inputCords;\n        this._directionY = this.directionY;\n        this._directionX = this.directionX;\n\n        this.append();\n    }\n\n    @HostListener('window:scroll')\n    changePosition(): void {\n      const {left, right, bottom, top} = this.inputCords;\n      const x = this.defineElementYByDirection(left, right);\n      const y = this.defineElementYByDirection(top, bottom);\n      this.setStyle('left', `${x}px`);\n      this.setStyle('top', `${y}px`);\n    }\n\n    private append(): void {\n        const {left, right, bottom, top} = this._inputCords;\n\n        const x = this.defineElementXByDirection(left, right);\n        const y = this.defineElementYByDirection(top, bottom);\n\n        this.setStyle('position', 'fixed');\n        this.setStyle('left', `${x}px`);\n        this.setStyle('top', `${y}px`);\n    }\n\n    private setStyle(style: string, value: string): void {\n        this.renderer.setStyle(this.element, style, value);\n    }\n\n    private defineElementYByDirection(inputTop: number, inputBottom: number): number {\n        if (this._directionY === 'top') {\n            return inputTop - this.element.offsetHeight;\n        } else if (this._directionY === 'center') {\n            return inputTop - (this.element.offsetHeight / 2);\n        }\n        return inputBottom;\n    }\n\n    private defineElementXByDirection(inputLeft: number, inputRight: number) {\n      // DEBUG\n      //console.log(\"defineElementXByDirection \", inputLeft, inputRight);\n\n      if (this._directionX === 'end') {\n        return inputRight - this.element.offsetWidth;\n      } else if (this._directionX === 'center') {\n        return inputRight - (this.element.offsetWidth / 2);\n      }\n      return inputLeft;\n    }\n}\n"]}

package/esm2022/src/app/shared/material/numpad/numpad.component.mjs

@@ -0,0 +1,83 @@
+import { DEFAULT_KEYMAP } from './numpad.model';
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { MatNumpadContainerComponent } from './numpad.container';
+import * as i0 from "@angular/core";
+import * as i1 from "./numpad.dom-service";
+export class MatNumpadComponent {
+    domService;
+    _inputRef;
+    _opened = false;
+    keymap = DEFAULT_KEYMAP;
+    decimal = true;
+    appendToInput;
+    disableAnimation = false;
+    noBackdrop = false;
+    position = 'bottom';
+    keypress = new EventEmitter();
+    closed = new EventEmitter();
+    get opened() {
+        return this._opened;
+    }
+    get inputElement() {
+        return this._inputRef && this._inputRef.element;
+    }
+    constructor(domService) {
+        this.domService = domService;
+    }
+    registerInput(input) {
+        if (this._inputRef) {
+            throw new Error('A Numpad can only be registered to one input.');
+        }
+        this._inputRef = input;
+    }
+    open() {
+        // Already open. Skip.
+        if (this._opened)
+            return;
+        console.debug('[numpad] Opening numpad...');
+        this.domService.appendNumpadToBody(MatNumpadContainerComponent, {
+            numpadRef: this,
+            decimal: this.decimal,
+            keymap: this.keymap,
+            inputElement: this.inputElement,
+            appendToInput: this.appendToInput,
+            disableAnimation: this.disableAnimation,
+            noBackdrop: this.noBackdrop,
+            position: this.position
+        });
+        this._opened = true;
+    }
+    close() {
+        console.debug('[numpad] Closing numpad...');
+        this.domService.destroyNumpad();
+        this._opened = false;
+        // Emit close event
+        this.closed.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MatNumpadComponent, deps: [{ token: i1.MatNumpadDomService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: MatNumpadComponent, selector: "mat-numpad", inputs: { keymap: "keymap", decimal: "decimal", appendToInput: "appendToInput", disableAnimation: "disableAnimation", noBackdrop: "noBackdrop", position: "position" }, outputs: { keypress: "keypress", closed: "closed" }, ngImport: i0, template: '', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MatNumpadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mat-numpad',
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatNumpadDomService }]; }, propDecorators: { keymap: [{
+                type: Input
+            }], decimal: [{
+                type: Input
+            }], appendToInput: [{
+                type: Input
+            }], disableAnimation: [{
+                type: Input
+            }], noBackdrop: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], keypress: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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