@openmrs/ngx-formentry 3.0.1-pre.100

package/esm2015/components/ngx-pick-datetime/lib/dialog/dialog.service.js

@@ -0,0 +1,233 @@
+/**
+ * dialog.service
+ */
+import { Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef } from '@angular/core';
+import { Location } from '@angular/common';
+import { OwlDialogConfig } from './dialog-config.class';
+import { OwlDialogRef } from './dialog-ref.class';
+import { OwlDialogContainerComponent } from './dialog-container.component';
+import { extendObject } from '../utils';
+import { defer, Subject } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { Overlay, OverlayConfig, OverlayContainer } from '@angular/cdk/overlay';
+import { ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+import * as i3 from "./dialog-config.class";
+export const OWL_DIALOG_DATA = new InjectionToken('OwlDialogData');
+/**
+ * Injection token that determines the scroll handling while the dialog is open.
+ * */
+export const OWL_DIALOG_SCROLL_STRATEGY = new InjectionToken('owl-dialog-scroll-strategy');
+export function OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+    const fn = () => overlay.scrollStrategies.block();
+    return fn;
+}
+/** @docs-private */
+export const OWL_DIALOG_SCROLL_STRATEGY_PROVIDER = {
+    provide: OWL_DIALOG_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY
+};
+/** I
+ * njection token that can be used to specify default dialog options.
+ * */
+export const OWL_DIALOG_DEFAULT_OPTIONS = new InjectionToken('owl-dialog-default-options');
+export class OwlDialogService {
+    constructor(overlay, injector, location, scrollStrategy, defaultOptions, parentDialog, overlayContainer) {
+        this.overlay = overlay;
+        this.injector = injector;
+        this.location = location;
+        this.defaultOptions = defaultOptions;
+        this.parentDialog = parentDialog;
+        this.overlayContainer = overlayContainer;
+        this.ariaHiddenElements = new Map();
+        this._openDialogsAtThisLevel = [];
+        this._afterOpenAtThisLevel = new Subject();
+        this._afterAllClosedAtThisLevel = new Subject();
+        /**
+         * Stream that emits when all open dialog have finished closing.
+         * Will emit on subscribe if there are no open dialogs to begin with.
+         */
+        this.afterAllClosed = defer(() => this._openDialogsAtThisLevel.length
+            ? this._afterAllClosed
+            : this._afterAllClosed.pipe(startWith(undefined)));
+        this.scrollStrategy = scrollStrategy;
+        if (!parentDialog && location) {
+            location.subscribe(() => this.closeAll());
+        }
+    }
+    /** Keeps track of the currently-open dialogs. */
+    get openDialogs() {
+        return this.parentDialog
+            ? this.parentDialog.openDialogs
+            : this._openDialogsAtThisLevel;
+    }
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpen() {
+        return this.parentDialog
+            ? this.parentDialog.afterOpen
+            : this._afterOpenAtThisLevel;
+    }
+    get _afterAllClosed() {
+        const parent = this.parentDialog;
+        return parent ? parent._afterAllClosed : this._afterAllClosedAtThisLevel;
+    }
+    open(componentOrTemplateRef, config) {
+        config = applyConfigDefaults(config, this.defaultOptions);
+        if (config.id && this.getDialogById(config.id)) {
+            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+        }
+        const overlayRef = this.createOverlay(config);
+        const dialogContainer = this.attachDialogContainer(overlayRef, config);
+        const dialogRef = this.attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config);
+        if (!this.openDialogs.length) {
+            this.hideNonDialogContentFromAssistiveTechnology();
+        }
+        this.openDialogs.push(dialogRef);
+        dialogRef.afterClosed().subscribe(() => this.removeOpenDialog(dialogRef));
+        this.afterOpen.next(dialogRef);
+        return dialogRef;
+    }
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll() {
+        let i = this.openDialogs.length;
+        while (i--) {
+            this.openDialogs[i].close();
+        }
+    }
+    /**
+     * Finds an open dialog by its id.
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById(id) {
+        return this.openDialogs.find((dialog) => dialog.id === id);
+    }
+    attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config) {
+        const dialogRef = new OwlDialogRef(overlayRef, dialogContainer, config.id, this.location);
+        if (config.hasBackdrop) {
+            overlayRef.backdropClick().subscribe(() => {
+                if (!dialogRef.disableClose) {
+                    dialogRef.close();
+                }
+            });
+        }
+        if (componentOrTemplateRef instanceof TemplateRef) {
+        }
+        else {
+            const injector = this.createInjector(config, dialogRef, dialogContainer);
+            const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, undefined, injector));
+            dialogRef.componentInstance = contentRef.instance;
+        }
+        dialogRef
+            .updateSize(config.width, config.height)
+            .updatePosition(config.position);
+        return dialogRef;
+    }
+    createInjector(config, dialogRef, dialogContainer) {
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        const injectionTokens = new WeakMap();
+        injectionTokens.set(OwlDialogRef, dialogRef);
+        injectionTokens.set(OwlDialogContainerComponent, dialogContainer);
+        injectionTokens.set(OWL_DIALOG_DATA, config.data);
+        return new PortalInjector(userInjector || this.injector, injectionTokens);
+    }
+    createOverlay(config) {
+        const overlayConfig = this.getOverlayConfig(config);
+        return this.overlay.create(overlayConfig);
+    }
+    attachDialogContainer(overlayRef, config) {
+        const containerPortal = new ComponentPortal(OwlDialogContainerComponent, config.viewContainerRef);
+        const containerRef = overlayRef.attach(containerPortal);
+        containerRef.instance.setConfig(config);
+        return containerRef.instance;
+    }
+    getOverlayConfig(dialogConfig) {
+        const state = new OverlayConfig({
+            positionStrategy: this.overlay.position().global(),
+            scrollStrategy: dialogConfig.scrollStrategy || this.scrollStrategy(),
+            panelClass: dialogConfig.paneClass,
+            hasBackdrop: dialogConfig.hasBackdrop,
+            minWidth: dialogConfig.minWidth,
+            minHeight: dialogConfig.minHeight,
+            maxWidth: dialogConfig.maxWidth,
+            maxHeight: dialogConfig.maxHeight
+        });
+        if (dialogConfig.backdropClass) {
+            state.backdropClass = dialogConfig.backdropClass;
+        }
+        return state;
+    }
+    removeOpenDialog(dialogRef) {
+        const index = this._openDialogsAtThisLevel.indexOf(dialogRef);
+        if (index > -1) {
+            this.openDialogs.splice(index, 1);
+            // If all the dialogs were closed, remove/restore the `aria-hidden`
+            // to a the siblings and emit to the `afterAllClosed` stream.
+            if (!this.openDialogs.length) {
+                this.ariaHiddenElements.forEach((previousValue, element) => {
+                    if (previousValue) {
+                        element.setAttribute('aria-hidden', previousValue);
+                    }
+                    else {
+                        element.removeAttribute('aria-hidden');
+                    }
+                });
+                this.ariaHiddenElements.clear();
+                this._afterAllClosed.next();
+            }
+        }
+    }
+    /**
+     * Hides all of the content that isn't an overlay from assistive technology.
+     */
+    hideNonDialogContentFromAssistiveTechnology() {
+        const overlayContainer = this.overlayContainer.getContainerElement();
+        // Ensure that the overlay container is attached to the DOM.
+        if (overlayContainer.parentElement) {
+            const siblings = overlayContainer.parentElement.children;
+            for (let i = siblings.length - 1; i > -1; i--) {
+                const sibling = siblings[i];
+                if (sibling !== overlayContainer &&
+                    sibling.nodeName !== 'SCRIPT' &&
+                    sibling.nodeName !== 'STYLE' &&
+                    !sibling.hasAttribute('aria-live')) {
+                    this.ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));
+                    sibling.setAttribute('aria-hidden', 'true');
+                }
+            }
+        }
+    }
+}
+OwlDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDialogService, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: i2.Location, optional: true }, { token: OWL_DIALOG_SCROLL_STRATEGY }, { token: OWL_DIALOG_DEFAULT_OPTIONS, optional: true }, { token: OwlDialogService, optional: true, skipSelf: true }, { token: i1.OverlayContainer }], target: i0.ɵɵFactoryTarget.Injectable });
+OwlDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.Location, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [OWL_DIALOG_SCROLL_STRATEGY]
+                }] }, { type: i3.OwlDialogConfig, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DIALOG_DEFAULT_OPTIONS]
+                }] }, { type: OwlDialogService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.OverlayContainer }]; } });
+/**
+ * Applies default options to the dialog config.
+ * @param config Config to be modified.
+ * @param defaultOptions Default config setting
+ * @returns The new configuration object.
+ */
+function applyConfigDefaults(config, defaultOptions) {
+    return extendObject(new OwlDialogConfig(), config, defaultOptions);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * dialog.service\n */\n\nimport {\n  ComponentRef,\n  Inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  Optional,\n  SkipSelf,\n  TemplateRef\n} from '@angular/core';\nimport { Location } from '@angular/common';\nimport { OwlDialogConfig } from './dialog-config.class';\nimport { OwlDialogRef } from './dialog-ref.class';\nimport { OwlDialogContainerComponent } from './dialog-container.component';\nimport { extendObject } from '../utils';\nimport { defer, Observable, Subject } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport {\n  Overlay,\n  OverlayConfig,\n  OverlayContainer,\n  OverlayRef,\n  ScrollStrategy\n} from '@angular/cdk/overlay';\nimport {\n  ComponentPortal,\n  ComponentType,\n  PortalInjector\n} from '@angular/cdk/portal';\n\nexport const OWL_DIALOG_DATA = new InjectionToken<any>('OwlDialogData');\n\n/**\n * Injection token that determines the scroll handling while the dialog is open.\n * */\nexport const OWL_DIALOG_SCROLL_STRATEGY = new InjectionToken<\n  () => ScrollStrategy\n>('owl-dialog-scroll-strategy');\n\nexport function OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(\n  overlay: Overlay\n): () => ScrollStrategy {\n  const fn = () => overlay.scrollStrategies.block();\n  return fn;\n}\n\n/** @docs-private */\nexport const OWL_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n  provide: OWL_DIALOG_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY\n};\n\n/** I\n * njection token that can be used to specify default dialog options.\n * */\nexport const OWL_DIALOG_DEFAULT_OPTIONS = new InjectionToken<OwlDialogConfig>(\n  'owl-dialog-default-options'\n);\n\n@Injectable()\nexport class OwlDialogService {\n  private ariaHiddenElements = new Map<Element, string | null>();\n\n  private _openDialogsAtThisLevel: OwlDialogRef<any>[] = [];\n  private _afterOpenAtThisLevel = new Subject<OwlDialogRef<any>>();\n  private _afterAllClosedAtThisLevel = new Subject<void>();\n\n  /** Keeps track of the currently-open dialogs. */\n  get openDialogs(): OwlDialogRef<any>[] {\n    return this.parentDialog\n      ? this.parentDialog.openDialogs\n      : this._openDialogsAtThisLevel;\n  }\n\n  /** Stream that emits when a dialog has been opened. */\n  get afterOpen(): Subject<OwlDialogRef<any>> {\n    return this.parentDialog\n      ? this.parentDialog.afterOpen\n      : this._afterOpenAtThisLevel;\n  }\n\n  get _afterAllClosed(): any {\n    const parent = this.parentDialog;\n    return parent ? parent._afterAllClosed : this._afterAllClosedAtThisLevel;\n  }\n\n  /**\n   * Stream that emits when all open dialog have finished closing.\n   * Will emit on subscribe if there are no open dialogs to begin with.\n   */\n\n  afterAllClosed: Observable<{}> = defer(() =>\n    this._openDialogsAtThisLevel.length\n      ? this._afterAllClosed\n      : this._afterAllClosed.pipe(startWith(undefined))\n  );\n\n  private scrollStrategy: () => ScrollStrategy;\n\n  constructor(\n    private overlay: Overlay,\n    private injector: Injector,\n    @Optional() private location: Location,\n    @Inject(OWL_DIALOG_SCROLL_STRATEGY) scrollStrategy: any,\n    @Optional()\n    @Inject(OWL_DIALOG_DEFAULT_OPTIONS)\n    private defaultOptions: OwlDialogConfig,\n    @Optional()\n    @SkipSelf()\n    private parentDialog: OwlDialogService,\n    private overlayContainer: OverlayContainer\n  ) {\n    this.scrollStrategy = scrollStrategy;\n    if (!parentDialog && location) {\n      location.subscribe(() => this.closeAll());\n    }\n  }\n\n  public open<T>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    config?: OwlDialogConfig\n  ): OwlDialogRef<any> {\n    config = applyConfigDefaults(config, this.defaultOptions);\n\n    if (config.id && this.getDialogById(config.id)) {\n      throw Error(\n        `Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`\n      );\n    }\n\n    const overlayRef = this.createOverlay(config);\n    const dialogContainer = this.attachDialogContainer(overlayRef, config);\n    const dialogRef = this.attachDialogContent<T>(\n      componentOrTemplateRef,\n      dialogContainer,\n      overlayRef,\n      config\n    );\n\n    if (!this.openDialogs.length) {\n      this.hideNonDialogContentFromAssistiveTechnology();\n    }\n\n    this.openDialogs.push(dialogRef);\n    dialogRef.afterClosed().subscribe(() => this.removeOpenDialog(dialogRef));\n    this.afterOpen.next(dialogRef);\n    return dialogRef;\n  }\n\n  /**\n   * Closes all of the currently-open dialogs.\n   */\n  public closeAll(): void {\n    let i = this.openDialogs.length;\n\n    while (i--) {\n      this.openDialogs[i].close();\n    }\n  }\n\n  /**\n   * Finds an open dialog by its id.\n   * @param id ID to use when looking up the dialog.\n   */\n  public getDialogById(id: string): OwlDialogRef<any> | undefined {\n    return this.openDialogs.find((dialog) => dialog.id === id);\n  }\n\n  private attachDialogContent<T>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    dialogContainer: OwlDialogContainerComponent,\n    overlayRef: OverlayRef,\n    config: OwlDialogConfig\n  ) {\n    const dialogRef = new OwlDialogRef<T>(\n      overlayRef,\n      dialogContainer,\n      config.id,\n      this.location\n    );\n\n    if (config.hasBackdrop) {\n      overlayRef.backdropClick().subscribe(() => {\n        if (!dialogRef.disableClose) {\n          dialogRef.close();\n        }\n      });\n    }\n\n    if (componentOrTemplateRef instanceof TemplateRef) {\n    } else {\n      const injector = this.createInjector<T>(\n        config,\n        dialogRef,\n        dialogContainer\n      );\n      const contentRef = dialogContainer.attachComponentPortal(\n        new ComponentPortal(componentOrTemplateRef, undefined, injector)\n      );\n      dialogRef.componentInstance = contentRef.instance;\n    }\n\n    dialogRef\n      .updateSize(config.width, config.height)\n      .updatePosition(config.position);\n\n    return dialogRef;\n  }\n\n  private createInjector<T>(\n    config: OwlDialogConfig,\n    dialogRef: OwlDialogRef<T>,\n    dialogContainer: OwlDialogContainerComponent\n  ) {\n    const userInjector =\n      config && config.viewContainerRef && config.viewContainerRef.injector;\n    const injectionTokens = new WeakMap();\n\n    injectionTokens.set(OwlDialogRef, dialogRef);\n    injectionTokens.set(OwlDialogContainerComponent, dialogContainer);\n    injectionTokens.set(OWL_DIALOG_DATA, config.data);\n\n    return new PortalInjector(userInjector || this.injector, injectionTokens);\n  }\n\n  private createOverlay(config: OwlDialogConfig): OverlayRef {\n    const overlayConfig = this.getOverlayConfig(config);\n    return this.overlay.create(overlayConfig);\n  }\n\n  private attachDialogContainer(\n    overlayRef: OverlayRef,\n    config: OwlDialogConfig\n  ): OwlDialogContainerComponent {\n    const containerPortal = new ComponentPortal(\n      OwlDialogContainerComponent,\n      config.viewContainerRef\n    );\n    const containerRef: ComponentRef<OwlDialogContainerComponent> = overlayRef.attach(\n      containerPortal\n    );\n    containerRef.instance.setConfig(config);\n\n    return containerRef.instance;\n  }\n\n  private getOverlayConfig(dialogConfig: OwlDialogConfig): OverlayConfig {\n    const state = new OverlayConfig({\n      positionStrategy: this.overlay.position().global(),\n      scrollStrategy: dialogConfig.scrollStrategy || this.scrollStrategy(),\n      panelClass: dialogConfig.paneClass,\n      hasBackdrop: dialogConfig.hasBackdrop,\n      minWidth: dialogConfig.minWidth,\n      minHeight: dialogConfig.minHeight,\n      maxWidth: dialogConfig.maxWidth,\n      maxHeight: dialogConfig.maxHeight\n    });\n\n    if (dialogConfig.backdropClass) {\n      state.backdropClass = dialogConfig.backdropClass;\n    }\n\n    return state;\n  }\n\n  private removeOpenDialog(dialogRef: OwlDialogRef<any>): void {\n    const index = this._openDialogsAtThisLevel.indexOf(dialogRef);\n\n    if (index > -1) {\n      this.openDialogs.splice(index, 1);\n      // If all the dialogs were closed, remove/restore the `aria-hidden`\n      // to a the siblings and emit to the `afterAllClosed` stream.\n      if (!this.openDialogs.length) {\n        this.ariaHiddenElements.forEach((previousValue, element) => {\n          if (previousValue) {\n            element.setAttribute('aria-hidden', previousValue);\n          } else {\n            element.removeAttribute('aria-hidden');\n          }\n        });\n\n        this.ariaHiddenElements.clear();\n        this._afterAllClosed.next();\n      }\n    }\n  }\n\n  /**\n   * Hides all of the content that isn't an overlay from assistive technology.\n   */\n  private hideNonDialogContentFromAssistiveTechnology() {\n    const overlayContainer = this.overlayContainer.getContainerElement();\n\n    // Ensure that the overlay container is attached to the DOM.\n    if (overlayContainer.parentElement) {\n      const siblings = overlayContainer.parentElement.children;\n\n      for (let i = siblings.length - 1; i > -1; i--) {\n        const sibling = siblings[i];\n\n        if (\n          sibling !== overlayContainer &&\n          sibling.nodeName !== 'SCRIPT' &&\n          sibling.nodeName !== 'STYLE' &&\n          !sibling.hasAttribute('aria-live')\n        ) {\n          this.ariaHiddenElements.set(\n            sibling,\n            sibling.getAttribute('aria-hidden')\n          );\n          sibling.setAttribute('aria-hidden', 'true');\n        }\n      }\n    }\n  }\n}\n\n/**\n * Applies default options to the dialog config.\n * @param config Config to be modified.\n * @param defaultOptions Default config setting\n * @returns The new configuration object.\n */\nfunction applyConfigDefaults(\n  config?: OwlDialogConfig,\n  defaultOptions?: OwlDialogConfig\n): OwlDialogConfig {\n  return extendObject(new OwlDialogConfig(), config, defaultOptions);\n}\n"]}

package/esm2015/components/ngx-pick-datetime/lib/utils/index.js

@@ -0,0 +1,5 @@
+/**
+ * index
+ */
+export * from './object.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtZm9ybWVudHJ5L3NyYy9jb21wb25lbnRzL25neC1waWNrLWRhdGV0aW1lL2xpYi91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGluZGV4XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9vYmplY3QudXRpbHMnO1xuIl19

package/esm2015/components/ngx-pick-datetime/lib/utils/object.utils.js

@@ -0,0 +1,26 @@
+/**
+ * object.utils
+ */
+/**
+ * Extends an object with the *enumerable* and *own* properties of one or more source objects,
+ * similar to Object.assign.
+ *
+ * @param dest The object which will have properties copied to it.
+ * @param sources The source objects from which properties will be copied.
+ */
+export function extendObject(dest, ...sources) {
+    if (dest == null) {
+        throw TypeError('Cannot convert undefined or null to object');
+    }
+    for (const source of sources) {
+        if (source != null) {
+            for (const key in source) {
+                if (source.hasOwnProperty(key)) {
+                    dest[key] = source[key];
+                }
+            }
+        }
+    }
+    return dest;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWZvcm1lbnRyeS9zcmMvY29tcG9uZW50cy9uZ3gtcGljay1kYXRldGltZS9saWIvdXRpbHMvb2JqZWN0LnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUg7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxJQUFTLEVBQUUsR0FBRyxPQUFjO0lBQ3ZELElBQUksSUFBSSxJQUFJLElBQUksRUFBRTtRQUNoQixNQUFNLFNBQVMsQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDO0tBQy9EO0lBRUQsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUU7UUFDNUIsSUFBSSxNQUFNLElBQUksSUFBSSxFQUFFO1lBQ2xCLEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxFQUFFO2dCQUN4QixJQUFJLE1BQU0sQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLEVBQUU7b0JBQzlCLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7aUJBQ3pCO2FBQ0Y7U0FDRjtLQUNGO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBvYmplY3QudXRpbHNcbiAqL1xuXG4vKipcbiAqIEV4dGVuZHMgYW4gb2JqZWN0IHdpdGggdGhlICplbnVtZXJhYmxlKiBhbmQgKm93biogcHJvcGVydGllcyBvZiBvbmUgb3IgbW9yZSBzb3VyY2Ugb2JqZWN0cyxcbiAqIHNpbWlsYXIgdG8gT2JqZWN0LmFzc2lnbi5cbiAqXG4gKiBAcGFyYW0gZGVzdCBUaGUgb2JqZWN0IHdoaWNoIHdpbGwgaGF2ZSBwcm9wZXJ0aWVzIGNvcGllZCB0byBpdC5cbiAqIEBwYXJhbSBzb3VyY2VzIFRoZSBzb3VyY2Ugb2JqZWN0cyBmcm9tIHdoaWNoIHByb3BlcnRpZXMgd2lsbCBiZSBjb3BpZWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBleHRlbmRPYmplY3QoZGVzdDogYW55LCAuLi5zb3VyY2VzOiBhbnlbXSk6IGFueSB7XG4gIGlmIChkZXN0ID09IG51bGwpIHtcbiAgICB0aHJvdyBUeXBlRXJyb3IoJ0Nhbm5vdCBjb252ZXJ0IHVuZGVmaW5lZCBvciBudWxsIHRvIG9iamVjdCcpO1xuICB9XG5cbiAgZm9yIChjb25zdCBzb3VyY2Ugb2Ygc291cmNlcykge1xuICAgIGlmIChzb3VyY2UgIT0gbnVsbCkge1xuICAgICAgZm9yIChjb25zdCBrZXkgaW4gc291cmNlKSB7XG4gICAgICAgIGlmIChzb3VyY2UuaGFzT3duUHJvcGVydHkoa2V5KSkge1xuICAgICAgICAgIGRlc3Rba2V5XSA9IHNvdXJjZVtrZXldO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIGRlc3Q7XG59XG4iXX0=

package/esm2015/components/ngx-remote-select/ngx-remote-select.component.js

@@ -0,0 +1,135 @@
+import { Component, Input, forwardRef, Output, EventEmitter, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { concat, of, Subject } from 'rxjs';
+import { catchError, distinctUntilChanged, switchMap, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-select/ng-select";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+export class RemoteSelectComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.remoteOptionsLoading = false;
+        this.remoteOptionInput$ = new Subject();
+        this.items = [];
+        this.value = [];
+        this.loading = false;
+        this.searchText = '';
+        this.notFoundMsg = 'match no found';
+        this.placeholder = 'Search...';
+        this.disabled = false;
+        this.theme = 'dark';
+        this.done = new EventEmitter();
+        this.compareItems = (item, selected) => {
+            if (item.value && selected.value) {
+                return item.value === selected.value;
+            }
+            return false;
+        };
+        // the method set in registerOnChange, it is just
+        // a placeholder for a method that takes one parameter,
+        // we use it to emit changes back to the form
+        this.propagateChange = (change) => { };
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+        if (this._dataSource && this._dataSource.dataFromSourceChanged) {
+            this.subscribeToDataSourceDataChanges();
+        }
+    }
+    ngOnInit() {
+        this.loadOptions();
+    }
+    subscribeToDataSourceDataChanges() {
+        this._dataSource.dataFromSourceChanged.subscribe((results) => {
+            if (results.length > 0) {
+                this.items = results;
+                this.notFoundMsg = '';
+            }
+            else {
+                this.notFoundMsg = 'Not found';
+                this.items = [];
+            }
+        });
+    }
+    // this is the initial value set to the component
+    writeValue(value) {
+        if (value && value !== '') {
+            if (this.dataSource) {
+                this.loading = true;
+                this.dataSource.resolveSelectedValue(value).subscribe((result) => {
+                    this.items = [result];
+                    this.selectedRemoteOptions = result;
+                    this.loading = false;
+                }, (error) => {
+                    this.loading = false;
+                });
+            }
+        }
+    }
+    // registers 'fn' that will be fired when changes are made
+    // this is how we emit the changes back to the form
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    // not used, used for touch input
+    registerOnTouched() { }
+    // change events from the textarea
+    onChange(event) {
+        this.propagateChange(event.id);
+        // .....
+        // update the form
+        // this.propagateChange(this.data);
+    }
+    selected(event) {
+        this.propagateChange(event);
+    }
+    trackByFn(item) {
+        return item.value;
+    }
+    loadOptions() {
+        this.remoteOptions$ = concat(of([]), // default items
+        this.remoteOptionInput$.pipe(distinctUntilChanged(), tap(() => {
+            this.loading = true;
+        }), switchMap((term) => this.dataSource.searchOptions(term).pipe(catchError(() => of([])), // empty list on error
+        tap(() => (this.loading = false))))));
+    }
+}
+RemoteSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RemoteSelectComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+RemoteSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: RemoteSelectComponent, selector: "ofe-remote-select", inputs: { placeholder: "placeholder", componentID: "componentID", disabled: "disabled", theme: "theme", dataSource: "dataSource" }, outputs: { done: "done" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => RemoteSelectComponent),
+            multi: true
+        }
+    ], ngImport: i0, template: "<div>\n  <ng-select\n    [ngClass]=\"{ 'afe-custom': theme === 'light' }\"\n    [disabled]=\"disabled\"\n    [items]=\"remoteOptions$ | async\"\n    bindLabel=\"label\"\n    bindValue=\"value\"\n    [multiple]=\"false\"\n    [hideSelected]=\"true\"\n    [compareWith]=\"compareItems\"\n    [trackByFn]=\"trackByFn\"\n    [loading]=\"loading\"\n    typeToSearchText=\"Please enter 2 or more characters\"\n    [typeahead]=\"remoteOptionInput$\"\n    [(ngModel)]=\"selectedRemoteOptions\"\n    (ngModelChange)=\"selected($event)\"\n  >\n  </ng-select>\n</div>\n", components: [{ type: i1.NgSelectComponent, selector: "ng-select", inputs: ["markFirst", "dropdownPosition", "loading", "closeOnSelect", "hideSelected", "selectOnTab", "bufferAmount", "selectableGroup", "selectableGroupAsModel", "searchFn", "trackByFn", "clearOnBackspace", "labelForId", "inputAttrs", "readonly", "searchWhileComposing", "minTermLength", "editableSearchTerm", "keyDownFn", "multiple", "addTag", "searchable", "clearable", "isOpen", "items", "compareWith", "clearSearchOnAdd", "bindLabel", "placeholder", "notFoundText", "typeToSearchText", "addTagText", "loadingText", "clearAllText", "virtualScroll", "openOnEnter", "appendTo", "bindValue", "appearance", "maxSelectedItems", "groupBy", "groupValue", "tabIndex", "typeahead"], outputs: ["blur", "focus", "change", "open", "close", "search", "clear", "add", "remove", "scroll", "scrollToEnd"] }], directives: [{ type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], pipes: { "async": i2.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RemoteSelectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ofe-remote-select',
+                    templateUrl: 'remote-select.component.html',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => RemoteSelectComponent),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { placeholder: [{
+                type: Input
+            }], componentID: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], done: [{
+                type: Output
+            }], dataSource: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-remote-select.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/components/ngx-remote-select/ngx-remote-select.component.ts","../../../../../projects/ngx-formentry/src/components/ngx-remote-select/remote-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  Input,\n  forwardRef,\n  ViewChild,\n  Output,\n  EventEmitter,\n  Renderer2\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { concat, Observable, of, Subject } from 'rxjs';\nimport {\n  catchError,\n  debounceTime,\n  distinctUntilChanged,\n  switchMap,\n  tap\n} from 'rxjs/operators';\nimport { SelectOption } from '../../form-entry/question-models/interfaces/select-option';\n\nimport { DataSource } from '../../form-entry/question-models/interfaces/data-source';\nimport * as _ from 'lodash';\n@Component({\n  selector: 'ofe-remote-select',\n  templateUrl: 'remote-select.component.html',\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => RemoteSelectComponent),\n      multi: true\n    }\n  ]\n})\nexport class RemoteSelectComponent implements OnInit, ControlValueAccessor {\n  // @Input() dataSource: DataSource;\n  remoteOptions$: Observable<SelectOption[]>;\n  remoteOptionsLoading = false;\n  remoteOptionInput$ = new Subject<string>();\n  selectedRemoteOptions: SelectOption;\n  items = [];\n  value = [];\n  loading = false;\n  searchText = '';\n  notFoundMsg = 'match no found';\n  @Input() placeholder = 'Search...';\n  @Input() componentID: string;\n  @Input() disabled = false;\n  @Input() theme = 'dark';\n  @Output() done: EventEmitter<any> = new EventEmitter<any>();\n\n  private _dataSource: DataSource;\n  @Input()\n  public get dataSource(): DataSource {\n    return this._dataSource;\n  }\n  public set dataSource(v: DataSource) {\n    this._dataSource = v;\n    if (this._dataSource && this._dataSource.dataFromSourceChanged) {\n      this.subscribeToDataSourceDataChanges();\n    }\n  }\n\n  constructor(private renderer: Renderer2) {}\n\n  ngOnInit() {\n    this.loadOptions();\n  }\n\n  subscribeToDataSourceDataChanges() {\n    this._dataSource.dataFromSourceChanged.subscribe((results) => {\n      if (results.length > 0) {\n        this.items = results;\n        this.notFoundMsg = '';\n      } else {\n        this.notFoundMsg = 'Not found';\n        this.items = [];\n      }\n    });\n  }\n\n  // this is the initial value set to the component\n  public writeValue(value: any) {\n    if (value && value !== '') {\n      if (this.dataSource) {\n        this.loading = true;\n        this.dataSource.resolveSelectedValue(value).subscribe(\n          (result: any) => {\n            this.items = [result];\n            this.selectedRemoteOptions = result;\n            this.loading = false;\n          },\n          (error) => {\n            this.loading = false;\n          }\n        );\n      }\n    }\n  }\n  // registers 'fn' that will be fired when changes are made\n  // this is how we emit the changes back to the form\n  public registerOnChange(fn: any) {\n    this.propagateChange = fn;\n  }\n\n  // not used, used for touch input\n  public registerOnTouched() {}\n  // change events from the textarea\n  onChange(event) {\n    this.propagateChange(event.id);\n    // .....\n    // update the form\n    // this.propagateChange(this.data);\n  }\n  selected(event) {\n    this.propagateChange(event);\n  }\n\n  compareItems = (item, selected) => {\n    if (item.value && selected.value) {\n      return item.value === selected.value;\n    }\n    return false;\n  };\n\n  // the method set in registerOnChange, it is just\n  // a placeholder for a method that takes one parameter,\n  // we use it to emit changes back to the form\n  private propagateChange = (change: any) => {};\n\n  trackByFn(item: SelectOption) {\n    return item.value;\n  }\n\n  private loadOptions() {\n    this.remoteOptions$ = concat(\n      of([]), // default items\n      this.remoteOptionInput$.pipe(\n        distinctUntilChanged(),\n        tap(() => {\n          this.loading = true;\n        }),\n        switchMap((term) =>\n          this.dataSource.searchOptions(term).pipe(\n            catchError(() => of([])), // empty list on error\n            tap(() => (this.loading = false))\n          )\n        )\n      )\n    );\n  }\n}\n","<div>\n  <ng-select\n    [ngClass]=\"{ 'afe-custom': theme === 'light' }\"\n    [disabled]=\"disabled\"\n    [items]=\"remoteOptions$ | async\"\n    bindLabel=\"label\"\n    bindValue=\"value\"\n    [multiple]=\"false\"\n    [hideSelected]=\"true\"\n    [compareWith]=\"compareItems\"\n    [trackByFn]=\"trackByFn\"\n    [loading]=\"loading\"\n    typeToSearchText=\"Please enter 2 or more characters\"\n    [typeahead]=\"remoteOptionInput$\"\n    [(ngModel)]=\"selectedRemoteOptions\"\n    (ngModelChange)=\"selected($event)\"\n  >\n  </ng-select>\n</div>\n"]}

package/esm2015/components/ngx-remote-select/ngx-remote-select.module.js

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { NgSelectModule } from '@ng-select/ng-select';
+import { RemoteSelectComponent } from './ngx-remote-select.component';
+import * as i0 from "@angular/core";
+export class NgxRemoteSelectModule {
+}
+NgxRemoteSelectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NgxRemoteSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxRemoteSelectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NgxRemoteSelectModule, declarations: [RemoteSelectComponent], imports: [CommonModule, NgSelectModule, FormsModule], exports: [RemoteSelectComponent] });
+NgxRemoteSelectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NgxRemoteSelectModule, providers: [], imports: [[CommonModule, NgSelectModule, FormsModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NgxRemoteSelectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, NgSelectModule, FormsModule],
+                    exports: [RemoteSelectComponent],
+                    declarations: [RemoteSelectComponent],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LXJlbW90ZS1zZWxlY3QubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWZvcm1lbnRyeS9zcmMvY29tcG9uZW50cy9uZ3gtcmVtb3RlLXNlbGVjdC9uZ3gtcmVtb3RlLXNlbGVjdC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7QUFRdEUsTUFBTSxPQUFPLHFCQUFxQjs7bUhBQXJCLHFCQUFxQjtvSEFBckIscUJBQXFCLGlCQUhqQixxQkFBcUIsYUFGMUIsWUFBWSxFQUFFLGNBQWMsRUFBRSxXQUFXLGFBQ3pDLHFCQUFxQjtvSEFJcEIscUJBQXFCLGFBRnJCLEVBQUUsWUFISixDQUFDLFlBQVksRUFBRSxjQUFjLEVBQUUsV0FBVyxDQUFDOzRGQUt6QyxxQkFBcUI7a0JBTmpDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGNBQWMsRUFBRSxXQUFXLENBQUM7b0JBQ3BELE9BQU8sRUFBRSxDQUFDLHFCQUFxQixDQUFDO29CQUNoQyxZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDckMsU0FBUyxFQUFFLEVBQUU7aUJBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBOZ1NlbGVjdE1vZHVsZSB9IGZyb20gJ0BuZy1zZWxlY3Qvbmctc2VsZWN0JztcbmltcG9ydCB7IFJlbW90ZVNlbGVjdENvbXBvbmVudCB9IGZyb20gJy4vbmd4LXJlbW90ZS1zZWxlY3QuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgTmdTZWxlY3RNb2R1bGUsIEZvcm1zTW9kdWxlXSxcbiAgZXhwb3J0czogW1JlbW90ZVNlbGVjdENvbXBvbmVudF0sXG4gIGRlY2xhcmF0aW9uczogW1JlbW90ZVNlbGVjdENvbXBvbmVudF0sXG4gIHByb3ZpZGVyczogW11cbn0pXG5leHBvcnQgY2xhc3MgTmd4UmVtb3RlU2VsZWN0TW9kdWxlIHt9XG4iXX0=

package/esm2015/components/ngx-tabset/components/ngx-tab-set.component.js

@@ -0,0 +1,76 @@
+import { Component, ContentChildren, Input, Output, EventEmitter } from '@angular/core';
+import { TabComponent } from './tab.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../directives/hover-class.directive";
+export class TabSetComponent {
+    constructor() {
+        this.disableStyle = false;
+        this.customNavClass = '';
+        this.customTabsClass = '';
+        this.selectedIndex = 0;
+        this.tabSelect = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        if (changes.selectedIndex && !changes.selectedIndex.firstChange) {
+            this.selectTab(this.tabs.toArray()[changes.selectedIndex.currentValue]);
+        }
+    }
+    // contentChildren are set
+    ngAfterContentInit() {
+        // get all active tabs
+        const activeTabs = this.tabs.filter((tab) => tab.active);
+        // if there is no active tab set, activate the first
+        setTimeout(() => {
+            if (activeTabs.length === 0) {
+                this.selectTab(this.tabs.first);
+            }
+        });
+    }
+    onHover($event) { }
+    selectTab(tabToSelect) {
+        if (tabToSelect.disabled === true || tabToSelect.active === true) {
+            return;
+        }
+        // deactivate all tabs
+        this.tabs.toArray().forEach((tab) => (tab.active = false));
+        // activate the tab the user has clicked on.
+        tabToSelect.active = true;
+        this.tabSelect.emit(this.tabs.toArray().indexOf(tabToSelect));
+    }
+    getStatusClasses(active, disabled) {
+        if (active) {
+            return 'active';
+        }
+        if (!disabled && !active) {
+            return 'enabled';
+        }
+        if (disabled) {
+            return 'disabled';
+        }
+    }
+}
+TabSetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TabSetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TabSetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: TabSetComponent, selector: "ofe-tab-set", inputs: { disableStyle: "disableStyle", customNavClass: "customNavClass", customTabsClass: "customTabsClass", selectedIndex: "selectedIndex" }, outputs: { tabSelect: "tabSelect" }, queries: [{ propertyName: "tabs", predicate: TabComponent }], usesOnChanges: true, ngImport: i0, template: "<div class=\"tab-container\">\n  <div class=\"tab\">\n    <button\n      ofeHoverClass=\"hover\"\n      class=\"tablinks completed\"\n      *ngFor=\"let tab of tabs\"\n      (click)=\"selectTab(tab)\"\n      [class]=\"getStatusClasses(tab.active, tab.disabled)\"\n    >\n      <span>{{ tab.tabTitle }}</span>\n    </button>\n  </div>\n  <div id=\"tab\" class=\"tab-content\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [".tab-container{overflow-x:hidden;display:flex}.tab{width:10rem;position:fixed}.tab button{font-family:inherit;display:block;background-color:inherit;width:100%;border:none;outline:none;text-align:left;transition:.3s;min-height:2rem;white-space:normal;word-wrap:break-word;margin:0 0 .063rem}.tab button :hover{cursor:pointer}@media screen and (max-width: 768px){.tab button{height:3rem;border-bottom:.0125rem solid var(--open-mrs-background-gray);width:10rem}}.tab button.active.hover{background-color:var(--gray-gray-10)}.tab button.enabled.hover{background-color:var(--gray-gray-10)}.tab button.completed{border-left:.5rem solid var(--inverse-support-02);background-color:var(--color-green-10);font-size:.875rem;font-weight:normal;font-stretch:normal;font-style:normal;line-height:1.43;letter-spacing:.16px;color:#161616}.tab button.active{background-color:#ededed;border-left:.5rem solid #009d9a;font-size:.875rem;font-weight:600;font-stretch:normal;font-style:normal;line-height:1.43;letter-spacing:.16px;color:#161616}.tab button.enabled{background-color:#fff;border-left:.5rem solid #9ef0f0;font-size:.875rem;font-weight:normal;font-stretch:normal;font-style:normal;line-height:1.43;letter-spacing:.16px;color:var(--color-gray-100)}.tab button.error{background-color:var(--color-red-10);border-left:.5rem solid var(--open-mrs-danger-red-60);font-size:.875rem;font-weight:normal;font-stretch:normal;font-style:normal;line-height:1.29;letter-spacing:.16px;color:#da1e28}.tab button.disabled{background-color:#fff;border-left:.5rem solid #dae0e0;font-size:.875rem;font-weight:normal;font-stretch:normal;font-style:normal;line-height:1.43;letter-spacing:.16px;color:var(--gray-gray-30)}.tab button.active.error{background-color:var(--color-red-20);border-left:.5rem solid var(--open-mrs-danger-red-60);font-size:.875rem;font-weight:600;font-stretch:normal;font-style:normal;line-height:1.29;letter-spacing:.16px;color:#da1e28}.tab-content{width:100%;margin-left:10rem}\n"], directives: [{ type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.HoverClassDirective, selector: "[ofeHoverClass]", inputs: ["hoverClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TabSetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ofe-tab-set',
+                    styleUrls: ['ngx-tab-set.component.scss'],
+                    templateUrl: 'ngx-tab-set.component.html'
+                }]
+        }], propDecorators: { tabs: [{
+                type: ContentChildren,
+                args: [TabComponent]
+            }], disableStyle: [{
+                type: Input
+            }], customNavClass: [{
+                type: Input
+            }], customTabsClass: [{
+                type: Input
+            }], selectedIndex: [{
+                type: Input
+            }], tabSelect: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/ngx-tabset/components/tab.component.js

@@ -0,0 +1,37 @@
+import { Component, Input, ContentChild, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class TabComponent {
+    constructor() {
+        this.active = false;
+        this.disabled = false;
+        this.bypassDOM = false;
+        this.customPaneClass = '';
+    }
+}
+TabComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TabComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TabComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: TabComponent, selector: "ofe-tab", inputs: { tabTitle: "tabTitle", tabSubTitle: "tabSubTitle", active: "active", disabled: "disabled", bypassDOM: "bypassDOM", customPaneClass: "customPaneClass" }, queries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0, template: "<div *ngIf=\"active\" class=\"pane\" [ngClass]=\"customPaneClass\">\n  <h4>{{ tabTitle }}</h4>\n  <div *ngIf=\"bypassDOM\">\n    <ng-container [ngTemplateOutlet]=\"template\"></ng-container>\n  </div>\n  <div *ngIf=\"!bypassDOM\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: ["h4{padding-left:1rem;margin-bottom:.5rem}h4:after{content:\"\";display:block;width:2rem;padding-top:.188rem;border-bottom:.375rem solid var(--brand-01)}.pane{background-color:#f4f4f4;margin:.5rem .125rem}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TabComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ofe-tab',
+                    templateUrl: 'tab.component.html',
+                    styleUrls: ['./tab.component.css']
+                }]
+        }], propDecorators: { tabTitle: [{
+                type: Input
+            }], tabSubTitle: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], bypassDOM: [{
+                type: Input
+            }], customPaneClass: [{
+                type: Input
+            }], template: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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