systelab-virtual-keyboard 0.0.1

package/esm2022/lib/systelab-virtual-keyboard.directive.mjs

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2020 - 2024 - Instrumentation Laboratory Company and Systelab Technologies, SA. All rights reserved.
+ * NOTICE:  All information contained herein is and remains the property of Instrumentation Laboratory Company and its
+ * affiliates, if any.  The intellectual and technical concepts contained herein are proprietary to Instrumentation
+ * Laboratory Company and its affiliates and may be covered by U.S. and foreign patents and patent applications, and/or
+ * are protected by trade secret or copyright law. Dissemination of this information or reproduction of this material is
+ * strictly forbidden unless prior written permission is Instrumentation Laboratory Company.
+ */
+import { Directive, HostListener, Inject, Input, Optional, } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { SystelabVirtualKeyboardInputTypes, SystelabVirtualKeyboardLayouts } from './constants';
+import { VIRTUAL_KEYBOARD_CONFIG } from './systelab-virtual-keyboard.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./systelab-virtual-keyboard-overlay.service";
+export class SystelabVirtualKeyboardDirective {
+    onDocumentClick(event) {
+        const simpleKeyboardElement = document.querySelector('.simple-keyboard');
+        const showKeyboardButtonClicked = event.target?.classList.contains('virtual-keyboard-show-button');
+        if (!simpleKeyboardElement?.contains(event.target) &&
+            !this.elementRef?.nativeElement?.contains(event.target) &&
+            !this.showKeyboardButtonElement?.contains(event.target) &&
+            !showKeyboardButtonClicked) {
+            if (this.overlayService.isCreated()) {
+                this.overlayService.destroy();
+            }
+        }
+    }
+    onDocumentScroll() {
+        if (this.overlayService.isCreated()) {
+            // update position and size on scroll
+        }
+    }
+    set vkEnabled(enabled) {
+        if (typeof enabled === 'string') {
+            this.enabled = true;
+        }
+        else {
+            this.enabled = enabled;
+        }
+    }
+    ;
+    get vkEnabled() {
+        return this.enabled;
+    }
+    get vkFixedBottom() {
+        return this.fixedBottom;
+    }
+    set vkFixedBottom(fixedBottom) {
+        if (typeof fixedBottom === 'string') {
+            this.fixedBottom = true;
+        }
+        else {
+            this.fixedBottom = fixedBottom;
+        }
+    }
+    get vkDebug() {
+        return this.debug;
+    }
+    set vkDebug(debug) {
+        this.debug = debug;
+    }
+    get vkConfig() {
+        return this.config;
+    }
+    set vkConfig(config) {
+        this.config = config;
+    }
+    constructor(elementRef, overlayService, renderer, document, virtualKeyboardConfig) {
+        this.elementRef = elementRef;
+        this.overlayService = overlayService;
+        this.renderer = renderer;
+        this.document = document;
+        this.virtualKeyboardConfig = virtualKeyboardConfig;
+        this.enabled = false;
+        this.fixedBottom = false;
+        this.debug = false;
+        this.config = this.virtualKeyboardConfig;
+    }
+    ngOnInit() {
+        this.attachKeyboardIcon();
+    }
+    ngAfterViewInit() {
+        if (this.vkEnabled) {
+            const keyboardIcon = this.elementRef.nativeElement.parentElement.querySelector('i');
+            keyboardIcon.addEventListener('click', this.togglePanel.bind(this));
+        }
+    }
+    ngOnDestroy() {
+        if (this.overlayService.isCreated()) {
+            this.overlayService.destroy();
+        }
+    }
+    togglePanel() {
+        if (this.overlayService.isOpen()) {
+            this.closePanel();
+        }
+        else {
+            this.openPanel();
+        }
+    }
+    openPanel() {
+        if (this.overlayService.isCreated()) {
+            this.overlayService.destroy();
+        }
+        if (this.overlayService.hasAttached()) {
+            return;
+        }
+        const currentLayout = this.getLayout(this.elementRef.nativeElement);
+        this.panelRef = this.overlayService.create(this.inputOrigin(), this.vkFixedBottom, currentLayout);
+        this.panelRef.instance.debug = this.vkDebug;
+        this.panelRef.instance.setActiveInput(this.elementRef.nativeElement);
+        this.panelRef.instance.setLayout(currentLayout);
+        this.panelRef.instance.closePanel.subscribe(() => this.closePanel());
+    }
+    getLayout(activeInputElement) {
+        if (this.config?.hasOwnProperty('layout')) {
+            return this.config.layout;
+        }
+        if (this.isInputAlphabetic(activeInputElement)) {
+            return SystelabVirtualKeyboardLayouts.default;
+        }
+        else if (this.isInputNumeric(activeInputElement)) {
+            return SystelabVirtualKeyboardLayouts.numeric;
+        }
+        else {
+            return SystelabVirtualKeyboardLayouts.default;
+        }
+    }
+    isInputAlphabetic(activeInputElement) {
+        const inputType = activeInputElement?.type;
+        return inputType && [SystelabVirtualKeyboardInputTypes.text, SystelabVirtualKeyboardInputTypes.password].some((i) => i === inputType);
+    }
+    isInputNumeric(activeInputElement) {
+        const inputType = activeInputElement?.type;
+        return inputType && [SystelabVirtualKeyboardInputTypes.number].some((i) => i === inputType);
+    }
+    closePanel() {
+        this.overlayService.destroy();
+    }
+    inputOrigin() {
+        return this.elementRef.nativeElement;
+    }
+    attachKeyboardIcon() {
+        if (this.vkEnabled) {
+            const child = this.document.createElement('i');
+            child.classList.add('fa');
+            child.classList.add('fa-keyboard');
+            child.classList.add('virtual-keyboard-show-button');
+            this.renderer.appendChild(this.elementRef.nativeElement.parentElement, child);
+            this.showKeyboardButtonElement = child;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SystelabVirtualKeyboardDirective, deps: [{ token: i0.ElementRef }, { token: i1.SystelabVirtualKeyboardOverlayService }, { token: i0.Renderer2 }, { token: DOCUMENT }, { token: VIRTUAL_KEYBOARD_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.9", type: SystelabVirtualKeyboardDirective, selector: "input[vkEnabled], textarea[vkEnabled]", inputs: { vkEnabled: "vkEnabled", vkFixedBottom: "vkFixedBottom", vkDebug: "vkDebug", vkConfig: "vkConfig" }, host: { listeners: { "document:click": "onDocumentClick($event)", "window:touchmove": "onDocumentScroll($event)", "window:touchend": "onDocumentScroll($event)", "window:wheel": "onDocumentScroll($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SystelabVirtualKeyboardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[vkEnabled], textarea[vkEnabled]',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.SystelabVirtualKeyboardOverlayService }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [VIRTUAL_KEYBOARD_CONFIG]
+                }] }], propDecorators: { onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }], onDocumentScroll: [{
+                type: HostListener,
+                args: ['window:touchmove', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['window:touchend', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['window:wheel', ['$event']]
+            }], vkEnabled: [{
+                type: Input
+            }], vkFixedBottom: [{
+                type: Input
+            }], vkDebug: [{
+                type: Input
+            }], vkConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"systelab-virtual-keyboard.directive.js","sourceRoot":"","sources":["../../../../projects/systelab-virtual-keyboard/src/lib/systelab-virtual-keyboard.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2020 - 2024 - Instrumentation Laboratory Company and Systelab Technologies, SA. All rights reserved.\n * NOTICE:  All information contained herein is and remains the property of Instrumentation Laboratory Company and its\n * affiliates, if any.  The intellectual and technical concepts contained herein are proprietary to Instrumentation\n * Laboratory Company and its affiliates and may be covered by U.S. and foreign patents and patent applications, and/or\n * are protected by trade secret or copyright law. Dissemination of this information or reproduction of this material is\n * strictly forbidden unless prior written permission is Instrumentation Laboratory Company.\n */\n\nimport {\n  AfterViewInit,\n  ComponentRef,\n  Directive,\n  ElementRef,\n  HostListener,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Renderer2,\n} from '@angular/core';\n\nimport { DOCUMENT } from '@angular/common';\n\nimport { SystelabVirtualKeyboardInputTypes, SystelabVirtualKeyboardLayouts } from './constants';\nimport { SystelabVirtualKeyboardComponent } from './systelab-virtual-keyboard.component';\nimport { SystelabVirtualKeyboardOverlayService } from './systelab-virtual-keyboard-overlay.service';\nimport { SystelabVirtualKeyboardConfig, VIRTUAL_KEYBOARD_CONFIG } from './systelab-virtual-keyboard.config';\n\n@Directive({\n  selector: 'input[vkEnabled], textarea[vkEnabled]',\n})\nexport class SystelabVirtualKeyboardDirective implements OnInit, AfterViewInit, OnDestroy {\n  @HostListener('document:click', ['$event'])\n  onDocumentClick(event: MouseEvent | TouchEvent) {\n    const simpleKeyboardElement = document.querySelector('.simple-keyboard');\n    const showKeyboardButtonClicked = (event.target as HTMLElement)?.classList.contains('virtual-keyboard-show-button');\n    if (\n      !simpleKeyboardElement?.contains(event.target as Node) &&\n      !this.elementRef?.nativeElement?.contains(event.target as Node) &&\n      !this.showKeyboardButtonElement?.contains(event.target as Node) &&\n      !showKeyboardButtonClicked\n    ) {\n      if (this.overlayService.isCreated()) {\n        this.overlayService.destroy();\n      }\n    }\n  }\n\n  @HostListener('window:touchmove', ['$event'])\n  @HostListener('window:touchend', ['$event'])\n  @HostListener('window:wheel', ['$event'])\n  onDocumentScroll() {\n    if (this.overlayService.isCreated()) {\n      // update position and size on scroll\n    }\n  }\n\n  private enabled = false;\n  @Input()\n  set vkEnabled(enabled: boolean | string) {\n    if (typeof enabled === 'string') {\n      this.enabled = true;\n    } else {\n      this.enabled = enabled;\n    }\n  };\n  get vkEnabled(): boolean {\n    return this.enabled;\n  }\n\n  private fixedBottom = false;\n  @Input()\n  get vkFixedBottom(): boolean {\n    return this.fixedBottom;\n  }\n  set vkFixedBottom(fixedBottom: boolean | string) {\n    if (typeof fixedBottom === 'string') {\n      this.fixedBottom = true;\n    } else {\n      this.fixedBottom = fixedBottom;\n    }\n  }\n\n  private debug = false;\n  @Input()\n  get vkDebug(): boolean {\n    return this.debug;\n  }\n  set vkDebug(debug: boolean) {\n    this.debug = debug;\n  }\n\n  private config: SystelabVirtualKeyboardConfig;\n  @Input()\n  get vkConfig(): SystelabVirtualKeyboardConfig {\n    return this.config;\n  }\n  set vkConfig(config: SystelabVirtualKeyboardConfig) {\n    this.config = config;\n  }\n\n  private panelRef!: ComponentRef<SystelabVirtualKeyboardComponent>;\n  private showKeyboardButtonElement: HTMLElement;\n\n  constructor(\n    private readonly elementRef: ElementRef<HTMLInputElement>,\n    private readonly overlayService: SystelabVirtualKeyboardOverlayService,\n    private readonly renderer: Renderer2,\n    @Inject(DOCUMENT) private readonly document: any,\n    @Optional() @Inject(VIRTUAL_KEYBOARD_CONFIG) private virtualKeyboardConfig: SystelabVirtualKeyboardConfig,\n  ) {\n    this.config = this.virtualKeyboardConfig;\n  }\n\n  ngOnInit() {\n    this.attachKeyboardIcon();\n  }\n\n  ngAfterViewInit() {\n    if (this.vkEnabled) {\n      const keyboardIcon = this.elementRef.nativeElement.parentElement.querySelector('i');\n      keyboardIcon.addEventListener('click', this.togglePanel.bind(this));\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.overlayService.isCreated()) {\n      this.overlayService.destroy();\n    }\n  }\n\n  private togglePanel(): void {\n    if (this.overlayService.isOpen()) {\n      this.closePanel();\n    } else {\n      this.openPanel();\n    }\n  }\n\n  private openPanel(): void {\n    if (this.overlayService.isCreated()) {\n      this.overlayService.destroy();\n    }\n    if (this.overlayService.hasAttached()) {\n      return;\n    }\n\n    const currentLayout = this.getLayout(this.elementRef.nativeElement);\n\n    this.panelRef = this.overlayService.create(this.inputOrigin(), this.vkFixedBottom, currentLayout);\n    this.panelRef.instance.debug = this.vkDebug;\n    this.panelRef.instance.setActiveInput(this.elementRef.nativeElement);\n    this.panelRef.instance.setLayout(currentLayout);\n    this.panelRef.instance.closePanel.subscribe(() => this.closePanel());\n  }\n\n  private getLayout(activeInputElement: HTMLInputElement | HTMLTextAreaElement): SystelabVirtualKeyboardLayouts {\n    if (this.config?.hasOwnProperty('layout')) {\n      return this.config.layout;\n    }\n    if (this.isInputAlphabetic(activeInputElement)) {\n      return SystelabVirtualKeyboardLayouts.default;\n    } else if (this.isInputNumeric(activeInputElement)) {\n      return SystelabVirtualKeyboardLayouts.numeric;\n    } else {\n      return SystelabVirtualKeyboardLayouts.default;\n    }\n  }\n\n  private isInputAlphabetic(activeInputElement: HTMLInputElement | HTMLTextAreaElement): boolean {\n    const inputType = activeInputElement?.type;\n    return inputType && [SystelabVirtualKeyboardInputTypes.text, SystelabVirtualKeyboardInputTypes.password].some((i) => i === inputType);\n  }\n\n  private isInputNumeric(activeInputElement: HTMLInputElement | HTMLTextAreaElement): boolean {\n    const inputType = activeInputElement?.type;\n    return inputType && [SystelabVirtualKeyboardInputTypes.number].some((i) => i === inputType);\n  }\n\n  private closePanel(): void {\n    this.overlayService.destroy();\n  }\n\n  private inputOrigin(): any {\n    return this.elementRef.nativeElement;\n  }\n\n  private attachKeyboardIcon() {\n    if (this.vkEnabled) {\n      const child = this.document.createElement('i');\n      child.classList.add('fa');\n      child.classList.add('fa-keyboard');\n      child.classList.add('virtual-keyboard-show-button');\n      this.renderer.appendChild(this.elementRef.nativeElement.parentElement, child);\n      this.showKeyboardButtonElement = child;\n    }\n  }\n}\n"]}

package/esm2022/lib/systelab-virtual-keyboard.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SystelabVirtualKeyboardDirective } from './systelab-virtual-keyboard.directive';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { VIRTUAL_KEYBOARD_CONFIG } from './systelab-virtual-keyboard.config';
+import { SystelabVirtualKeyboardOverlayService } from './systelab-virtual-keyboard-overlay.service';
+import * as i0 from "@angular/core";
+export const factory = () => {
+    const systelabVirtualKeyboardModuleCreated = factory._systelabVirtualKeyboardModuleCreated || false;
+    if (systelabVirtualKeyboardModuleCreated) {
+        throw new Error('SystelabVirtualKeyboardModuleCreated.forRoot imported to many times');
+    }
+    factory._systelabVirtualKeyboardModuleCreated = true;
+};
+export class SystelabVirtualKeyboardModule {
+    static forRoot(conf) {
+        return {
+            ngModule: SystelabVirtualKeyboardModule,
+            providers: [
+                SystelabVirtualKeyboardOverlayService,
+                {
+                    provide: VIRTUAL_KEYBOARD_CONFIG, useValue: conf
+                }
+            ]
+        };
+    }
+    static forChild() {
+        return {
+            ngModule: SystelabVirtualKeyboardModule,
+            providers: [],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SystelabVirtualKeyboardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.9", ngImport: i0, type: SystelabVirtualKeyboardModule, declarations: [SystelabVirtualKeyboardDirective], imports: [CommonModule, OverlayModule], exports: [SystelabVirtualKeyboardDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SystelabVirtualKeyboardModule, imports: [CommonModule, OverlayModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: SystelabVirtualKeyboardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OverlayModule],
+                    declarations: [SystelabVirtualKeyboardDirective],
+                    exports: [SystelabVirtualKeyboardDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -0,0 +1,7 @@
+/*
+ * Public API Surface of systelab-virtual-keyboard
+ */
+export * from './lib/constants';
+export * from './lib/systelab-virtual-keyboard.directive';
+export * from './lib/systelab-virtual-keyboard.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N5c3RlbGFiLXZpcnR1YWwta2V5Ym9hcmQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGlCQUFpQixDQUFDO0FBRWhDLGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyx3Q0FBd0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygc3lzdGVsYWItdmlydHVhbC1rZXlib2FyZFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbnN0YW50cyc7XG5leHBvcnQgeyBTeXN0ZWxhYlZpcnR1YWxLZXlib2FyZENvbmZpZyB9IGZyb20gJy4vbGliL3N5c3RlbGFiLXZpcnR1YWwta2V5Ym9hcmQuY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N5c3RlbGFiLXZpcnR1YWwta2V5Ym9hcmQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N5c3RlbGFiLXZpcnR1YWwta2V5Ym9hcmQubW9kdWxlJztcbiJdfQ==

package/esm2022/systelab-virtual-keyboard.mjs

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