ngx-beacon-notify 1.0.0 → 1.2.0

package/beacon-notify.service.ts

@@ -1,634 +0,0 @@
-import { Injectable, Inject, ViewChild, EventEmitter, ElementRef } from '@angular/core';
-import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
-import { BeaconNotifyComponent } from './beacon/beacon.component';
-import { Buffer } from 'buffer';
-import {
-  IBeaconConfig,
-  IBeaconInlineConfig,
-  IBeaconGlobalConfig,
-  IBeaconType,
-  IBeaconPositionConfig,
-  IBeaconEvent,
-  IBeaconWatchedEvent,
-  IBeaconEventMessage,
-  IBeaconTypeIcon,
-  IBeaconButtonType,
-  BEACON_GLOBAL_CONFIG,
-  BEACON_OVERLAY_COLOR,
-  BEACON_OVERLAY_ID
-} from './types';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class BeaconNotifyService {
-  private beaconDefaultIconKeys = ['a.a', 'a.e', 'a.i', 'a.s', 'a.w']
-  private beaconConfigMap: { [key: string]: { [key: string]: string } } = {
-    alert: { icon: this.beaconDefaultIconKeys[0], fontIcon: 'false', class: 'beacon-message-alert', title: 'Alert', style: '', animation: '', type: 'alert' },
-    error: { icon: this.beaconDefaultIconKeys[1], fontIcon: 'false', class: 'beacon-message-error', title: 'Error', style: '', animation: '', type: 'error' },
-    info: { icon: this.beaconDefaultIconKeys[2], fontIcon: 'false', class: 'beacon-message-info', title: 'Information', style: '', animation: '', type: 'info' },
-    success: { icon: this.beaconDefaultIconKeys[3], fontIcon: 'false', class: 'beacon-message-success', title: 'Success', style: '', animation: '', type: 'success' },
-    warning: { icon: this.beaconDefaultIconKeys[4], fontIcon: 'false', class: 'beacon-message-warning', title: 'Warning', style: '', animation: '', type: 'warning' }
-  }
-  private beaconTypeMap: { [key: string]: string } = {
-    a: 'success', b: 'error', c: 'warning', d: 'info', e: 'alert'
-  }
-  private beaconTitle?: string
-  private beaconMessage?: string
-  private beaconIcon?: string
-  private beaconManualId?: string
-  private beaconSelectedManualId?: string
-  private beaconIconFromFont?: true
-  private beaconStatic?: true | number
-  private beaconFixed?: true
-  private beaconBlockOthers?: true
-  private beaconPreventClickClose?: true
-  private beaconAllowDuplicate?: true
-  private beaconFocus?: true
-  private beaconFocusShine?: true
-  private beaconOverlayColor?: string
-  private beaconStyleClass?: string
-  private beaconReplacementClass?: string
-  private beaconAnimationClass?: string
-  private beaconNoHoverEffect?: true
-  private beaconGlobalStatic?: true | number
-  private beaconGlobalFixed?: true
-  private beaconGlobalBlockOthers?: true
-  private beaconGlobalPreventClickClose?: true
-  private beaconGlobalDuplicate?: boolean
-  private beaconGlobalNoHoverEffect?: true
-  private beaconGlobalPositioning?: IBeaconPositionConfig
-  private beaconGlobalFocusOverlayColor?: string
-  private beaconContainer!: ElementRef
-  private beaconDefaultAnimationClassName: string = 'beacon-message-control-animate'
-  private beaconSuccessorBlockerAutoId?: string
-  private beaconWithActiveFocusAutoId?: string
-  private beaconButtons: IBeaconButtonType = {}
-  private beaconFocusOrderLibrary: Array<string> = []
-  private beaconSubscribedEventLibrary: { [key: string]: { [key: string]: string | EventEmitter<IBeaconEvent> } } = {}
-  private beaconWatchedEventLibrary: Map<string, string> = new Map<string, string>([])
-  private beaconWatchedEventTaskMaster: EventEmitter<IBeaconWatchedEvent> = new EventEmitter<IBeaconWatchedEvent>()
-  private beaconAllEventTaskMaster: EventEmitter<IBeaconWatchedEvent> = new EventEmitter<IBeaconWatchedEvent>()
-  private beaconFocusOverlayDOM?: HTMLElement
-  public beaconEventTaskMaster: EventEmitter<{ [key: string]: boolean| string }> = new EventEmitter<{ [key: string]: boolean | string }>()
-  public beaconLibrary: Array<IBeaconConfig> = []
-  public beaconLibraryQueue: Array<IBeaconConfig> = []
-  
-  constructor(private sanitizer: DomSanitizer,
-    @Inject(BEACON_GLOBAL_CONFIG) private globalConfig?: IBeaconGlobalConfig) {
-    this.globalConfig && this.resolveGlobalConfig(this.globalConfig)
-    // Resolve events
-    this.resolveBeaconEvents()
-  }
-
-  // Resolve global config
-  private resolveGlobalConfig(globalConfig: IBeaconGlobalConfig): void {
-    if (globalConfig.static) {
-      if (typeof globalConfig.static == 'boolean') {
-        this.beaconGlobalFixed = undefined
-        this.beaconGlobalStatic = true
-      } else this.beaconGlobalStatic = globalConfig.static
-    }
-
-    if (globalConfig.fixed) {
-      this.beaconGlobalStatic = undefined
-      this.beaconGlobalFixed = true
-    }
-
-    globalConfig.preventClickClose && (this.beaconGlobalPreventClickClose = globalConfig.preventClickClose)
-    globalConfig.blockOthers && (this.beaconGlobalBlockOthers = globalConfig.blockOthers)
-    globalConfig.overlayColor && (this.beaconGlobalFocusOverlayColor = globalConfig.overlayColor)
-    globalConfig.duplicate && (this.beaconGlobalDuplicate = globalConfig.duplicate)
-    globalConfig.icon && this.resolveGlobalIconConfig(globalConfig.icon)
-    globalConfig.styleClass && this.resolveGlobalPropertyConfig(globalConfig.styleClass, 'style')
-    globalConfig.replacementClass && this.resolveGlobalPropertyConfig(globalConfig.replacementClass, 'class')
-    globalConfig.animationClass && this.resolveGlobalPropertyConfig(globalConfig.animationClass, 'animation')
-    globalConfig.position && (this.beaconGlobalPositioning = globalConfig.position)
-    globalConfig.noHoverEffect && (this.beaconGlobalNoHoverEffect = globalConfig.noHoverEffect)
-  }
-
-  // Resolve global config / for property
-  private resolveGlobalPropertyConfig(config: IBeaconType, property: string): void {
-    config.alert && (this.beaconConfigMap.alert[property] = config.alert)
-    config.error && (this.beaconConfigMap.error[property] = config.error)
-    config.info && (this.beaconConfigMap.info[property] = config.info)
-    config.success && (this.beaconConfigMap.success[property] = config.success)
-    config.warning && (this.beaconConfigMap.warning[property] = config.warning)
-  }
-
-  // Resolve global config / for icons
-  private resolveGlobalIconConfig(config: IBeaconTypeIcon): void {
-    config?.alert?.icon && (this.beaconConfigMap.alert.icon = config.alert.icon) && (this.beaconConfigMap.alert.fontIcon = String((config?.alert?.fontIcon || false)))
-    config?.error?.icon && (this.beaconConfigMap.error.icon = config.error.icon) && (this.beaconConfigMap.error.fontIcon = String((config?.error?.fontIcon || false)))
-    config?.info?.icon && (this.beaconConfigMap.info.icon = config.info.icon) && (this.beaconConfigMap.info.fontIcon = String((config.info.fontIcon || false)))
-    config?.success?.icon && (this.beaconConfigMap.success.icon = config.success.icon) && (this.beaconConfigMap.success.fontIcon = String((config.success.fontIcon || false)))
-    config?.warning?.icon && (this.beaconConfigMap.warning.icon = config.warning.icon) && (this.beaconConfigMap.warning.fontIcon = String((config.warning.fontIcon || false)))
-  }
-
-  // Resolve beacon events
-  private resolveBeaconEvents(): void {
-    this.beaconEventTaskMaster.subscribe((message: IBeaconEventMessage) => {
-      const id = String(message.id)
-      if (message.delete) {
-        this.resolvePossibleBlockedBeacons(id)
-        this.resolvePossibleQueuedFocus(id)
-        this.performEventTask(id, { on: false, off: true })
-        delete this.beaconSubscribedEventLibrary[id]
-      } else if (message.mount) {
-        this.performEventTask(id, { on: true, off: false })
-      }
-    })
-  }
-
-  // Perform event task
-  private performEventTask(id: string, eventObject: IBeaconEvent): void {
-    const stamp = this.beaconSubscribedEventLibrary[id]
-    const event = <EventEmitter<IBeaconEvent>>stamp.event
-    const manualId = stamp?.manualId?.toString().replace(/undefined/, '')
-    event.emit(eventObject)
-    this.beaconAllEventTaskMaster.emit({ id: manualId || null, type: String(stamp.type), ...eventObject })
-
-    // Check if this manual id is watched
-    if (manualId && this.beaconWatchedEventLibrary.has(manualId)) {
-      this.beaconWatchedEventTaskMaster.emit({ id: manualId, type: String(stamp.type), ...eventObject })
-      // Check if beacon is off
-      if (eventObject.off) 
-        this.beaconWatchedEventLibrary.delete(manualId)
-    }
-  }
-
-  // Resolve possible blocked beacons
-  private resolvePossibleBlockedBeacons(id: string): void {
-    // Check if this id is blocking others
-    if (id == this.beaconSuccessorBlockerAutoId) {
-      if (this.beaconLibraryQueue.length) {
-        const queueLength = this.beaconLibraryQueue.length
-        // Loop through queue
-        for (let x = 0; x < queueLength; x++) {
-          const nextInLine = <IBeaconConfig>this.beaconLibraryQueue.shift()
-
-          // Add message to library
-          if (this.getBeaconGlobalPositionConfig?.topBottom == 'top')
-            this.beaconLibrary.unshift(nextInLine)
-          else this.beaconLibrary.push(nextInLine)    
-
-          // Check if set to block
-          if (nextInLine.blockOthers) {
-            this.beaconSuccessorBlockerAutoId = nextInLine.bid
-            break
-          }
-        }
-
-        // Check if no new beacon is set as blocker and unset previous value
-        if (id == this.beaconSuccessorBlockerAutoId) 
-          this.beaconSuccessorBlockerAutoId = undefined
-      }
-      else this.beaconSuccessorBlockerAutoId = undefined
-    }
-  }
-
-  // Resolve queued beacon focus
-  private resolvePossibleQueuedFocus(id: string): void {
-    // Check if this id is active focus beacon
-    if (id == this.beaconWithActiveFocusAutoId) {
-      if (this.beaconFocusOrderLibrary.length) {
-        // Pass the next focus
-        this.beaconWithActiveFocusAutoId = this.beaconFocusOrderLibrary.shift()
-        this.beaconEventTaskMaster.emit({ autoDetectNextFocusBeacon: true })
-      }
-      else {
-        this.beaconWithActiveFocusAutoId = undefined
-        this.destroyBeaconFocusOverlay()
-      }
-    }
-  }
-
-  // Generate unique id for item
-  private get getId(): string {
-    return crypto.getRandomValues(new Uint32Array(2)).toString().split(',').join('')
-  }
-
-  // Set beacon container
-  public setBeaconContainer(container: ElementRef): void {
-    this.beaconContainer = container
-  }
-
-  // Get beacon container
-  public get getBeaconContainer(): ElementRef {
-    return this.beaconContainer
-  }
-
-  // Get beacon global position config
-  public get getBeaconGlobalPositionConfig(): IBeaconPositionConfig | undefined {
-    return this.beaconGlobalPositioning
-  }
-
-  // Get default icon keys
-  public get getBeaconDefaultIconKeys(): string[] {
-    return this.beaconDefaultIconKeys
-  }
-
-  // Get active focus beacon id
-  public get getActiveFocusBeaconId(): string | undefined {
-    return this.beaconWithActiveFocusAutoId
-  }
-
-  // Create overlay for focused beacon
-  public createBeaconFocusOverlay(overlayColor?: string): void {
-    const overlay = document.createElement('div')
-    overlay.setAttribute('id', BEACON_OVERLAY_ID)
-    overlay.style.position = 'fixed'
-    overlay.style.top = '0'
-    overlay.style.bottom = '0'
-    overlay.style.right = '0'
-    overlay.style.left = '0'
-    overlay.style.zIndex = '9002'
-    overlay.style.background = overlayColor || this.beaconGlobalFocusOverlayColor || BEACON_OVERLAY_COLOR
-    document.body.style.overflow = 'hidden'
-
-    // Pass overlay element
-    this.beaconFocusOverlayDOM = overlay
-
-    this.beaconContainer.nativeElement.appendChild(overlay)
-  }
-
-  // Repaint overlay for focused beacon
-  public repaintBeaconFocusOverlay(overlayColor?: string): void {
-    if (this.beaconFocusOverlayDOM)
-      this.beaconFocusOverlayDOM.style.background = overlayColor || this.beaconGlobalFocusOverlayColor || BEACON_OVERLAY_COLOR
-  }
-
-  // Destroy overlay for focused beacon
-  public destroyBeaconFocusOverlay(): void {
-    document.body.style.overflow = 'auto'
-    this.beaconContainer.nativeElement.querySelector('div#' + BEACON_OVERLAY_ID).remove()
-    this.beaconFocusOverlayDOM = undefined
-  }
-
-  // Set id for beacon
-  public id(id: string): BeaconNotifyService {
-    id && (this.beaconManualId = id)
-    return this
-  }
-
-  // Set notification title
-  public title(title: string): BeaconNotifyService {
-    title && (this.beaconTitle = title)
-    return this
-  }
-
-  // Set notification message
-  public message(message: string): BeaconNotifyService {
-    message && (this.beaconMessage = message)
-    return this
-  }
-
-  // Highlight id of beacon to update
-  public select(id: string): BeaconNotifyService {
-    id && (this.beaconSelectedManualId = id)
-    return this
-  }
-
-  // Change notification title
-  public setTitle(title: string): void {
-    // Check for active manual id / and if a beacon is tied to it
-    if (this.beaconSelectedManualId) {
-      const beaconIndex = this.beaconLibrary.findIndex(x => x.mid == this.beaconSelectedManualId)
-      if (beaconIndex >= 0)
-        this.beaconLibrary[beaconIndex].title = title
-    }
-  }
-
-  // Change notification message
-  public setMessage(message: string): void {
-    // Check for active manual id / and if a beacon is tied to it
-    if (this.beaconSelectedManualId) {
-      const beaconIndex = this.beaconLibrary.findIndex(x => x.mid == this.beaconSelectedManualId)
-      if (beaconIndex >= 0)
-        this.beaconLibrary[beaconIndex].body = message
-    }
-  }
-
-  // Change notification title & message
-  public setContent(title: string, message: string): void {
-    // Check for active manual id / and if a beacon is tied to it
-    if (this.beaconSelectedManualId) {
-      const beaconIndex = this.beaconLibrary.findIndex(x => x.mid == this.beaconSelectedManualId)
-      if (beaconIndex >= 0)
-        this.beaconLibrary[beaconIndex].title = title
-        this.beaconLibrary[beaconIndex].body = message
-    }
-  }
-
-  // Update beacon button 1
-  public setButtonOne(text: string, canDismiss?: boolean | null, callback?: any, callbackArgs?: any[] | null, position?: 'left' | 'center' | 'right'): void {
-    // Check for active manual id / and if a beacon is tied to it
-    if (this.beaconSelectedManualId) {
-      const beaconIndex = this.beaconLibrary.findIndex(x => x.mid == this.beaconSelectedManualId)
-      if (beaconIndex >= 0) {
-        (<IBeaconButtonType>this.beaconLibrary[beaconIndex].buttons).one = {
-          text: text.substring(0, 15),
-          canDismiss,
-          callback,
-          callbackArgs,
-          position
-        }
-      }
-    }
-  }
-
-  // Update beacon button 2
-  public setButtonTwo(text: string, canDismiss?: boolean | null, callback?: any, callbackArgs?: any[] | null, position?: 'left' | 'center' | 'right'): void {
-    // Check for active manual id / and if a beacon is tied to it
-    if (this.beaconSelectedManualId) {
-      const beaconIndex = this.beaconLibrary.findIndex(x => x.mid == this.beaconSelectedManualId)
-      if (beaconIndex >= 0) {
-        if (this.beaconLibrary[beaconIndex].buttons?.one) {
-          (<IBeaconButtonType>this.beaconLibrary[beaconIndex].buttons).two = {
-            text: text.substring(0, 15),
-            canDismiss,
-            callback,
-            callbackArgs,
-            position
-          }
-        } else this.setButtonOne(text, canDismiss, callback, callbackArgs, position)
-      }
-    }
-  }
-
-  // Set beacon as static or with delay
-  public static(delay?: number): BeaconNotifyService {
-    this.beaconStatic = delay || true
-    this.beaconFixed = undefined
-    return this
-  }
-
-  // Set beacon as fixed which removes the close button and disallows close on click
-  public fixed(): BeaconNotifyService {
-    this.beaconStatic = undefined
-    this.beaconFixed = true
-    return this
-  }
-
-  // Allow beacon to block others
-  public block(): BeaconNotifyService {
-    this.beaconBlockOthers = true
-    return this
-  }
-
-  // Focus on beacon
-  public focus(overlayColor?: string): BeaconNotifyService {
-    overlayColor && (this.beaconOverlayColor = overlayColor)
-    this.beaconFocus = true
-    return this
-  }
-
-  // Focus beacon on center screen
-  public shine(overlayColor?: string): BeaconNotifyService {
-    overlayColor && (this.beaconOverlayColor = overlayColor)
-    this.beaconFocusShine = this.beaconFocus = true
-    return this
-  }
-
-  // Add button for beacon
-  public button(text: string, canDismiss?: boolean | null, callback?: any, callbackArgs?: any[] | null, position?: 'left' | 'center' | 'right'): BeaconNotifyService {
-    if (!this.beaconButtons?.one) {
-      this.beaconButtons.one = {
-        text: text.substring(0, 15),
-        canDismiss,
-        callback,
-        callbackArgs,
-        position
-      }
-    } else if (this.beaconButtons.one && !this.beaconButtons.two) {
-      this.beaconButtons.two = {
-        text: text.substring(0, 15),
-        canDismiss,
-        callback,
-        callbackArgs,
-        position
-      }
-    }
-
-    return this
-  }
-
-  // Allow duplicate for beacon
-  public duplicate(): BeaconNotifyService {
-    this.beaconAllowDuplicate = true
-    return this
-  }
-
-  // Set config values for beacon
-  public build(config: IBeaconInlineConfig): BeaconNotifyService {
-    if (config.static) {
-      if (typeof config.static == 'boolean')
-        this.static()
-      else this.static(Number(config.static))
-    }
-
-    config.fixed && this.fixed()
-    config.duplicate && this.duplicate()
-    config.preventClickClose && (this.beaconPreventClickClose = config.preventClickClose)
-    config.blockOthers && (this.beaconBlockOthers = config.blockOthers)
-    config.focus && (this.beaconFocus = config.focus)
-    config.shine && (this.beaconFocusShine = this.beaconFocus = config.shine)
-    config.icon && (this.beaconIcon = config.icon)
-    config.fontIcon && (this.beaconIconFromFont = config.fontIcon)
-    config.styleClass && (this.beaconStyleClass = config.styleClass)
-    config.replacementClass && (this.beaconReplacementClass = config.replacementClass)
-    config.animationClass && (this.beaconAnimationClass = config.animationClass)
-    config.animationClass && (this.beaconAnimationClass = config.animationClass)
-    config.overlayColor && (this.beaconOverlayColor = config.overlayColor)
-    config.noHoverEffect && (this.beaconNoHoverEffect = config.noHoverEffect)
-    return this
-  }
-
-  // create notification beacon
-  private beacon(message: string, type: string): EventEmitter<IBeaconEvent> {
-    // Get signature
-    const signature = Buffer.from((this.beaconTitle || this.beaconConfigMap[type].title) + '.' + message).toString('base64')
-    // Generate beacon id
-    const beaconId = this.getId
-    // Register beacon in event library
-    this.beaconSubscribedEventLibrary[beaconId] = Object.create({})
-    // Check for duplicate if set to prevent or proceed if turned off
-    if (this.beaconAllowDuplicate || (([undefined, false].includes(this.beaconGlobalDuplicate) && this.isNewBeaconADuplicate(signature) == !1) || this.beaconGlobalDuplicate)) {
-      const beaconObject: IBeaconConfig = {
-        bid: beaconId,
-        mid: this.beaconManualId,
-        type: this.beaconConfigMap[type].class,
-        icon: this.beaconIcon || this.beaconConfigMap[type].icon,
-        fontIcon: this.beaconIconFromFont || (this.beaconConfigMap[type].fontIcon == 'true' ? true : undefined),
-        title: this.beaconTitle || this.beaconConfigMap[type].title,
-        static: this.beaconStatic || this.beaconGlobalStatic,
-        fixed: this.beaconFixed || this.beaconGlobalFixed,
-        preventClickClose: this.beaconPreventClickClose || this.beaconGlobalPreventClickClose,
-        styleClass: this.beaconStyleClass || this.beaconConfigMap[type].style,
-        replacementClass: this.beaconReplacementClass,
-        animationClass: this.beaconAnimationClass || this.beaconConfigMap[type].animation || this.beaconDefaultAnimationClassName,
-        blockOthers: this.beaconBlockOthers || this.beaconGlobalBlockOthers,
-        buttons: this.beaconButtons,
-        overlayColor: this.beaconOverlayColor,
-        bodyHtml: <SafeHtml>this.sanitizer.bypassSecurityTrustHtml(message),
-        body: message,
-        focus: this.beaconFocus,
-        shine: this.beaconFocusShine,
-        noHoverEffect: this.beaconNoHoverEffect || this.beaconGlobalNoHoverEffect,
-        signature
-      }
-
-      // Sanitize icon if passed
-      if (!beaconObject.fontIcon && beaconObject.icon && !this.beaconDefaultIconKeys.includes(beaconObject.icon)) {
-        beaconObject.svgIcon = <SafeHtml>this.sanitizer.bypassSecurityTrustHtml(beaconObject.icon)
-      }
-
-      // Check if there is an active beacon blocking others and add build beacon to queue
-      if (this.beaconSuccessorBlockerAutoId) {
-        this.beaconLibraryQueue.push(beaconObject)
-      } else {
-        // Check if beacon can block and register id
-        if (beaconObject.blockOthers)
-          this.beaconSuccessorBlockerAutoId = beaconObject.bid
-
-        // Add message to library
-        if (this.getBeaconGlobalPositionConfig?.topBottom == 'top')
-          this.beaconLibrary.unshift(beaconObject)
-        else this.beaconLibrary.push(beaconObject)
-      }
-
-      // Check if beacon has focus
-      if (this.beaconFocus) {
-        if (this.beaconWithActiveFocusAutoId)
-          this.beaconFocusOrderLibrary.push(beaconObject.bid)
-        else
-          this.beaconWithActiveFocusAutoId = beaconObject.bid
-      }
-
-      // Check if id is set and register it
-      if (this.beaconManualId) {
-        this.beaconSubscribedEventLibrary[beaconId].manualId = this.beaconManualId
-        // Map the defined id to the auto-gen id
-        this.beaconWatchedEventLibrary.set(this.beaconManualId, beaconId)
-      }
-
-      // Register beacon type 
-      this.beaconSubscribedEventLibrary[beaconId].type = this.beaconConfigMap[type].type
-    }
-
-    // Register event for beacon
-    this.beaconSubscribedEventLibrary[beaconId].event = new EventEmitter<IBeaconEvent>()
-
-    // Reset
-    this.beaconTitle = undefined
-    this.beaconMessage = undefined
-    this.beaconStatic = undefined
-    this.beaconFixed = undefined
-    this.beaconBlockOthers = undefined
-    this.beaconManualId = undefined
-    this.beaconFocus = undefined
-    this.beaconFocusShine = undefined
-    this.beaconOverlayColor = undefined
-    this.beaconAllowDuplicate = undefined
-    this.beaconNoHoverEffect = undefined
-    this.beaconIcon = undefined
-    this.beaconIconFromFont = undefined
-    this.beaconStyleClass = undefined
-    this.beaconReplacementClass = undefined
-    this.beaconAnimationClass = undefined
-    this.beaconButtons = {}
-
-    return <EventEmitter<IBeaconEvent>>this.beaconSubscribedEventLibrary[beaconId].event
-  }
-
-  // Set notification message / success
-  public success(...message: string[]): EventEmitter<IBeaconEvent> {
-    // Set title
-    (message.length > 1) && message[0] && this.title(message[0])
-    // Set body
-    return this.beacon(message[1] || message[0] || this.beaconMessage || this.beaconConfigMap.success.title, this.beaconTypeMap.a)
-  }
-
-  // Set notification message / error
-  public error(...message: string[]): EventEmitter<IBeaconEvent> {
-    // Set title
-    (message.length > 1) && message[0] && this.title(message[0])
-    // Set body
-    return this.beacon(message[1] || message[0] || this.beaconMessage || this.beaconConfigMap.error.title, this.beaconTypeMap.b)
-  }
-
-  // Set notification message / warning
-  public warning(...message: string[]): EventEmitter<IBeaconEvent> {
-    // Set title
-    (message.length > 1) && message[0] && this.title(message[0])
-    // Set body
-    return this.beacon(message[1] || message[0] || this.beaconMessage || this.beaconConfigMap.warning.title, this.beaconTypeMap.c)
-  }
-
-  // Set notification message / info
-  public info(...message: string[]): EventEmitter<IBeaconEvent> {
-    // Set title
-    (message.length > 1) && message[0] && this.title(message[0])
-    // Set body
-    return this.beacon(message[1] || message[0] || this.beaconMessage || this.beaconConfigMap.info.title, this.beaconTypeMap.d)
-  }
-
-  // Set notification message / alert
-  public alert(...message: string[]): EventEmitter<IBeaconEvent> {
-    // Set title
-    (message.length > 1) && message[0] && this.title(message[0])
-    // Set body
-    return this.beacon(message[1] || message[0] || this.beaconMessage || this.beaconConfigMap.alert.title, this.beaconTypeMap.e)
-  }
-
-  // Watch events for beacon with specified id
-  public watch(id: string | string[]): EventEmitter<IBeaconWatchedEvent> {
-    // Register watched id
-    if (Array.isArray(id))
-      id.forEach(k => this.beaconWatchedEventLibrary.set(k, String()))
-    else this.beaconWatchedEventLibrary.set(id, String())
-
-    return this.beaconWatchedEventTaskMaster
-  }
-
-  // Watch events for all beacons
-  public events(): EventEmitter<IBeaconWatchedEvent> {
-    return this.beaconAllEventTaskMaster
-  }
-
-  // Close beacon with id
-  public closeOne(id: string): void {
-    if (this.beaconWatchedEventLibrary.has(id)) {
-      const autoId = <string>this.beaconWatchedEventLibrary.get(id)
-
-      // Remove the beacon
-      this.beaconLibrary = this.beaconLibrary.filter(x => {
-        return (x.bid != autoId)
-      })
-
-      this.beaconEventTaskMaster.emit({
-        delete: true,
-        id: autoId
-      })
-    }
-  }
-
-  // Close all beacons
-  public closeAll(): void {
-    this.beaconLibrary = this.beaconLibrary.filter(x => {
-      this.beaconEventTaskMaster.emit({
-        delete: true,
-        id: x.bid
-      })
-
-      return !(x.bid)
-    })
-  }
-
-  // Check for possible duplicate
-  private isNewBeaconADuplicate(signature: string): boolean {
-    const duplicate = this.beaconLibrary.find(x => x.signature == signature)
-    const beacon = this.beaconContainer.nativeElement.querySelector(`div#bc_${duplicate?.bid}`)
-    return Boolean(beacon && window.getComputedStyle(beacon).opacity == '1')
-  }
-}

package/container/container.component.css

@@ -1,10 +0,0 @@
-#app-beacon-notify-container {
-	position: fixed;
-	height: auto;
-	width: auto;
-	right: 0;
-	left: auto;
-	top: 0;
-	bottom: auto;
-	z-index: 3999;
-}

package/container/container.component.html

@@ -1,3 +0,0 @@
-<div id="app-beacon-notify-container" #beaconContainer>
-	<app-beacon *ngFor="let beacon of beaconLibrary; trackBy: trackBy" [id]="'bcp_'+beacon.bid" [beacon]="beacon"></app-beacon>
-</div>

package/container/container.component.spec.ts

@@ -1,21 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { BeaconNotifyContainerComponent } from './container.component';
-
-describe('BeaconNotifyContainerComponent', () => {
-  let component: BeaconNotifyContainerComponent;
-  let fixture: ComponentFixture<BeaconNotifyContainerComponent>;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      declarations: [BeaconNotifyContainerComponent]
-    });
-    fixture = TestBed.createComponent(BeaconNotifyContainerComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});