angular-onscreen-material-keyboard
Version:
This package is forked from ngx-material-keyboard with bug fixes and additional features
196 lines • 25.1 kB
JavaScript
import { LiveAnnouncer } from '@angular/cdk/a11y';
import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
import { ComponentPortal } from '@angular/cdk/portal';
import { Inject, Injectable, LOCALE_ID, Optional, SkipSelf } from '@angular/core';
import { MatKeyboardRef } from '../classes/keyboard-ref.class';
import { MatKeyboardContainerComponent } from '../components/keyboard-container/keyboard-container.component';
import { MatKeyboardComponent } from '../components/keyboard/keyboard.component';
import { MAT_KEYBOARD_LAYOUTS } from '../configs/keyboard-layouts.config';
import { _applyAvailableLayouts, _applyConfigDefaults } from '../utils/keyboard.utils';
/**
* Service to dispatch Material Design keyboard.
*/
export class MatKeyboardService {
constructor(_overlay, _live, _defaultLocale, _layouts, _parentKeyboard) {
this._overlay = _overlay;
this._live = _live;
this._defaultLocale = _defaultLocale;
this._layouts = _layouts;
this._parentKeyboard = _parentKeyboard;
/**
* Reference to the current keyboard in the view *at this level* (in the Angular injector tree).
* If there is a parent keyboard service, all operations should delegate to that parent
* via `_openedKeyboardRef`.
*/
this._keyboardRefAtThisLevel = null;
this._availableLocales = {};
// prepare available layouts mapping
this._availableLocales = _applyAvailableLayouts(_layouts);
}
/** Reference to the currently opened keyboard at *any* level. */
get _openedKeyboardRef() {
const parent = this._parentKeyboard;
return parent ? parent._openedKeyboardRef : this._keyboardRefAtThisLevel;
}
set _openedKeyboardRef(value) {
if (this._parentKeyboard) {
this._parentKeyboard._openedKeyboardRef = value;
}
else {
this._keyboardRefAtThisLevel = value;
}
}
get availableLocales() {
return this._availableLocales;
}
get isOpened() {
return !!this._openedKeyboardRef;
}
/**
* Creates and dispatches a keyboard with a custom component for the content, removing any
* currently opened keyboards.
*
* @param layoutOrLocale layout or locale to use.
* @param config Extra configuration for the keyboard.
*/
openFromComponent(layoutOrLocale, config) {
const keyboardRef = this._attachKeyboardContent(config);
keyboardRef.instance.darkTheme = config.darkTheme;
keyboardRef.instance.isDebug = config.isDebug;
// a locale is provided
if (this.availableLocales[layoutOrLocale]) {
keyboardRef.instance.locale = layoutOrLocale;
keyboardRef.instance.layout = this.getLayoutForLocale(layoutOrLocale);
}
// a layout name is provided
if (this._layouts[layoutOrLocale]) {
keyboardRef.instance.layout = this._layouts[layoutOrLocale];
keyboardRef.instance.locale = this._layouts[layoutOrLocale].lang && this._layouts[layoutOrLocale].lang.pop();
}
if (config.customIcons) {
keyboardRef.instance.icons = config.customIcons;
}
// When the keyboard is dismissed, lower the keyboard counter.
keyboardRef
.afterDismissed()
.subscribe(() => {
// Clear the keyboard ref if it hasn't already been replaced by a newer keyboard.
if (this._openedKeyboardRef === keyboardRef) {
this._openedKeyboardRef = null;
}
});
if (this._openedKeyboardRef) {
// If a keyboard is already in view, dismiss it and enter the
// new keyboard after exit animation is complete.
this._openedKeyboardRef
.afterDismissed()
.subscribe(() => {
keyboardRef.containerInstance.enter();
});
this._openedKeyboardRef.dismiss();
}
else {
// If no keyboard is in view, enter the new keyboard.
keyboardRef.containerInstance.enter();
}
// If a dismiss timeout is provided, set up dismiss based on after the keyboard is opened.
// if (configs.duration > 0) {
// keyboardRef.afterOpened().subscribe(() => {
// setTimeout(() => keyboardRef.dismiss(), configs.duration);
// });
// }
if (config.announcementMessage) {
this._live.announce(config.announcementMessage, config.politeness);
}
this._openedKeyboardRef = keyboardRef;
return this._openedKeyboardRef;
}
/**
* Opens a keyboard with a message and an optional action.
* @param layoutOrLocale A string representing the locale or the layout name to be used.
* @param config Additional configuration options for the keyboard.
*/
open(layoutOrLocale = this._defaultLocale, config = {}) {
const _config = _applyConfigDefaults(config);
return this.openFromComponent(layoutOrLocale, _config);
}
/**
* Dismisses the currently-visible keyboard.
*/
dismiss() {
if (this._openedKeyboardRef) {
this._openedKeyboardRef.dismiss();
}
}
/**
* Map a given locale to a layout name.
* @param locale The layout name
*/
mapLocale(locale = this._defaultLocale) {
let layout;
const country = locale
.split('-')
.shift();
// search for layout matching the
// first part, the country code
if (this.availableLocales[country]) {
layout = this.availableLocales[locale];
}
// look if the detailed locale matches any layout
if (this.availableLocales[locale]) {
layout = this.availableLocales[locale];
}
if (!layout) {
throw Error(`No layout found for locale ${locale}`);
}
return layout;
}
getLayoutForLocale(locale) {
return this._layouts[this.mapLocale(locale)];
}
/**
* Attaches the keyboard container component to the overlay.
*/
_attachKeyboardContainer(overlayRef, config) {
const containerPortal = new ComponentPortal(MatKeyboardContainerComponent, config.viewContainerRef);
const containerRef = overlayRef.attach(containerPortal);
// set config
containerRef.instance.keyboardConfig = config;
return containerRef.instance;
}
/**
* Places a new component as the content of the keyboard container.
*/
_attachKeyboardContent(config) {
const overlayRef = this._createOverlay();
const container = this._attachKeyboardContainer(overlayRef, config);
const portal = new ComponentPortal(MatKeyboardComponent);
const contentRef = container.attachComponentPortal(portal);
return new MatKeyboardRef(contentRef.instance, container, overlayRef);
}
/**
* Creates a new overlay and places it in the correct location.
*/
_createOverlay() {
const state = new OverlayConfig({
width: '100%'
});
state.positionStrategy = this._overlay
.position()
.global()
.centerHorizontally()
.bottom('0');
return this._overlay.create(state);
}
}
MatKeyboardService.decorators = [
{ type: Injectable }
];
MatKeyboardService.ctorParameters = () => [
{ type: Overlay },
{ type: LiveAnnouncer },
{ type: String, decorators: [{ type: Inject, args: [LOCALE_ID,] }] },
{ type: undefined, decorators: [{ type: Inject, args: [MAT_KEYBOARD_LAYOUTS,] }] },
{ type: MatKeyboardService, decorators: [{ type: Optional }, { type: SkipSelf }] }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyboard.service.js","sourceRoot":"","sources":["../../../../src/core/src/services/keyboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { LiveAnnouncer } from '@angular/cdk/a11y';\nimport { Overlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { ComponentRef, Inject, Injectable, LOCALE_ID, Optional, SkipSelf } from '@angular/core';\n\nimport { MatKeyboardRef } from '../classes/keyboard-ref.class';\nimport { MatKeyboardContainerComponent } from '../components/keyboard-container/keyboard-container.component';\nimport { MatKeyboardComponent } from '../components/keyboard/keyboard.component';\nimport { MAT_KEYBOARD_LAYOUTS } from '../configs/keyboard-layouts.config';\nimport { MatKeyboardConfig } from '../configs/keyboard.config';\nimport { IKeyboardLayout } from '../interfaces/keyboard-layout.interface';\nimport { IKeyboardLayouts } from '../interfaces/keyboard-layouts.interface';\nimport { ILocaleMap } from '../interfaces/locale-map.interface';\nimport { _applyAvailableLayouts, _applyConfigDefaults } from '../utils/keyboard.utils';\n\n/**\n * Service to dispatch Material Design keyboard.\n */\n@Injectable()\nexport class MatKeyboardService {\n  /**\n   * Reference to the current keyboard in the view *at this level* (in the Angular injector tree).\n   * If there is a parent keyboard service, all operations should delegate to that parent\n   * via `_openedKeyboardRef`.\n   */\n  private _keyboardRefAtThisLevel: MatKeyboardRef<MatKeyboardComponent> | null = null;\n\n  private _availableLocales: ILocaleMap = {};\n\n  /** Reference to the currently opened keyboard at *any* level. */\n  private get _openedKeyboardRef(): MatKeyboardRef<MatKeyboardComponent> | null {\n    const parent = this._parentKeyboard;\n    return parent ? parent._openedKeyboardRef : this._keyboardRefAtThisLevel;\n  }\n\n  private set _openedKeyboardRef(value: MatKeyboardRef<MatKeyboardComponent>) {\n    if (this._parentKeyboard) {\n      this._parentKeyboard._openedKeyboardRef = value;\n    } else {\n      this._keyboardRefAtThisLevel = value;\n    }\n  }\n\n  get availableLocales(): ILocaleMap {\n    return this._availableLocales;\n  }\n\n  get isOpened(): boolean {\n    return !!this._openedKeyboardRef;\n  }\n\n  constructor(private _overlay: Overlay,\n              private _live: LiveAnnouncer,\n              @Inject(LOCALE_ID) private _defaultLocale: string,\n              @Inject(MAT_KEYBOARD_LAYOUTS) private _layouts: IKeyboardLayouts,\n              @Optional() @SkipSelf() private _parentKeyboard: MatKeyboardService) {\n    // prepare available layouts mapping\n    this._availableLocales = _applyAvailableLayouts(_layouts);\n  }\n\n  /**\n   * Creates and dispatches a keyboard with a custom component for the content, removing any\n   * currently opened keyboards.\n   *\n   * @param layoutOrLocale layout or locale to use.\n   * @param config Extra configuration for the keyboard.\n   */\n  openFromComponent(layoutOrLocale: string, config: MatKeyboardConfig): MatKeyboardRef<MatKeyboardComponent> {\n    const keyboardRef: MatKeyboardRef<MatKeyboardComponent> = this._attachKeyboardContent(config);\n\n    keyboardRef.instance.darkTheme = config.darkTheme;\n    keyboardRef.instance.isDebug = config.isDebug;\n\n    // a locale is provided\n    if (this.availableLocales[layoutOrLocale]) {\n      keyboardRef.instance.locale = layoutOrLocale;\n      keyboardRef.instance.layout = this.getLayoutForLocale(layoutOrLocale);\n    }\n\n    // a layout name is provided\n    if (this._layouts[layoutOrLocale]) {\n      keyboardRef.instance.layout = this._layouts[layoutOrLocale];\n      keyboardRef.instance.locale = this._layouts[layoutOrLocale].lang && this._layouts[layoutOrLocale].lang.pop();\n    }\n\n    if (config.customIcons) {\n      keyboardRef.instance.icons = config.customIcons;\n    }\n\n    // When the keyboard is dismissed, lower the keyboard counter.\n    keyboardRef\n      .afterDismissed()\n      .subscribe(() => {\n        // Clear the keyboard ref if it hasn't already been replaced by a newer keyboard.\n        if (this._openedKeyboardRef === keyboardRef) {\n          this._openedKeyboardRef = null;\n        }\n      });\n\n    if (this._openedKeyboardRef) {\n      // If a keyboard is already in view, dismiss it and enter the\n      // new keyboard after exit animation is complete.\n      this._openedKeyboardRef\n        .afterDismissed()\n        .subscribe(() => {\n          keyboardRef.containerInstance.enter();\n        });\n      this._openedKeyboardRef.dismiss();\n    } else {\n      // If no keyboard is in view, enter the new keyboard.\n      keyboardRef.containerInstance.enter();\n    }\n\n    // If a dismiss timeout is provided, set up dismiss based on after the keyboard is opened.\n    // if (configs.duration > 0) {\n    //   keyboardRef.afterOpened().subscribe(() => {\n    //     setTimeout(() => keyboardRef.dismiss(), configs.duration);\n    //   });\n    // }\n\n    if (config.announcementMessage) {\n      this._live.announce(config.announcementMessage, config.politeness);\n    }\n\n    this._openedKeyboardRef = keyboardRef;\n    return this._openedKeyboardRef;\n  }\n\n  /**\n   * Opens a keyboard with a message and an optional action.\n   * @param layoutOrLocale A string representing the locale or the layout name to be used.\n   * @param config Additional configuration options for the keyboard.\n   */\n  open(layoutOrLocale: string = this._defaultLocale, config: MatKeyboardConfig = {}): MatKeyboardRef<MatKeyboardComponent> {\n    const _config = _applyConfigDefaults(config);\n\n    return this.openFromComponent(layoutOrLocale, _config);\n  }\n\n  /**\n   * Dismisses the currently-visible keyboard.\n   */\n  dismiss() {\n    if (this._openedKeyboardRef) {\n      this._openedKeyboardRef.dismiss();\n    }\n  }\n\n  /**\n   * Map a given locale to a layout name.\n   * @param locale The layout name\n   */\n  mapLocale(locale: string = this._defaultLocale): string {\n    let layout: string;\n    const country = locale\n      .split('-')\n      .shift();\n\n    // search for layout matching the\n    // first part, the country code\n    if (this.availableLocales[country]) {\n      layout = this.availableLocales[locale];\n    }\n\n    // look if the detailed locale matches any layout\n    if (this.availableLocales[locale]) {\n      layout = this.availableLocales[locale];\n    }\n\n    if (!layout) {\n      throw Error(`No layout found for locale ${locale}`);\n    }\n\n    return layout;\n  }\n\n  getLayoutForLocale(locale: string): IKeyboardLayout {\n    return this._layouts[this.mapLocale(locale)];\n  }\n\n  /**\n   * Attaches the keyboard container component to the overlay.\n   */\n  private _attachKeyboardContainer(overlayRef: OverlayRef, config: MatKeyboardConfig): MatKeyboardContainerComponent {\n    const containerPortal = new ComponentPortal(MatKeyboardContainerComponent, config.viewContainerRef);\n    const containerRef: ComponentRef<MatKeyboardContainerComponent> = overlayRef.attach(containerPortal);\n\n    // set config\n    containerRef.instance.keyboardConfig = config;\n\n    return containerRef.instance;\n  }\n\n  /**\n   * Places a new component as the content of the keyboard container.\n   */\n  private _attachKeyboardContent(config: MatKeyboardConfig): MatKeyboardRef<MatKeyboardComponent> {\n    const overlayRef = this._createOverlay();\n    const container = this._attachKeyboardContainer(overlayRef, config);\n    const portal = new ComponentPortal(MatKeyboardComponent);\n    const contentRef = container.attachComponentPortal(portal);\n    return new MatKeyboardRef(contentRef.instance, container, overlayRef) as MatKeyboardRef<MatKeyboardComponent>;\n  }\n\n  /**\n   * Creates a new overlay and places it in the correct location.\n   */\n  private _createOverlay(): OverlayRef {\n    const state = new OverlayConfig({\n      width: '100%'\n    });\n\n    state.positionStrategy = this._overlay\n      .position()\n      .global()\n      .centerHorizontally()\n      .bottom('0');\n\n    return this._overlay.create(state);\n  }\n}\n"]}