theme-lib
Version:
This is a simple example Angular Library published to npm.
354 lines • 31.2 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { ApplicationRef, ComponentFactoryResolver, Directive, Inject, Injectable, Injector, NgModule, NgZone, } from '@angular/core';
import { CdkPortal, CdkPortalOutlet, ComponentPortal, DomPortalOutlet, PortalInjector, PortalModule, TemplatePortal, } from '@angular/cdk/portal';
import { FlexibleConnectedPositionStrategy, Overlay, OverlayConfig, OverlayContainer, OverlayKeyboardDispatcher, OverlayModule, OverlayPositionBuilder, OverlayRef, ScrollStrategyOptions, } from '@angular/cdk/overlay';
import { Platform } from '@angular/cdk/platform';
import { Directionality } from '@angular/cdk/bidi';
import { NB_DOCUMENT } from '../../../theme.options';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common";
export class NbPortalDirective extends CdkPortal {
}
NbPortalDirective.decorators = [
{ type: Directive, args: [{ selector: '[nbPortal]' },] }
];
export class NbPortalOutletDirective extends CdkPortalOutlet {
}
NbPortalOutletDirective.decorators = [
{ type: Directive, args: [{ selector: '[nbPortalOutlet]' },] }
];
/**
* @template T
*/
export class NbComponentPortal extends ComponentPortal {
/**
* @param {?} component
* @param {?=} vcr
* @param {?=} injector
* @param {?=} cfr
*/
constructor(component, vcr, injector, cfr) {
super(component, vcr, injector);
this.cfr = cfr;
}
}
if (false) {
/** @type {?} */
NbComponentPortal.prototype.cfr;
}
/*
* TODO remove after @angular/cdk@7.0.0 relased
* */
export class NbDomPortalOutlet extends DomPortalOutlet {
/**
* @param {?} outletElement
* @param {?} componentFactoryResolver
* @param {?} appRef
* @param {?} defaultInjector
*/
constructor(outletElement, componentFactoryResolver, appRef, defaultInjector) {
super(outletElement, componentFactoryResolver, appRef, defaultInjector);
this.outletElement = outletElement;
this.componentFactoryResolver = componentFactoryResolver;
this.appRef = appRef;
this.defaultInjector = defaultInjector;
}
/*
* Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.
* @param portal Portal to be attached
* @returns Reference to the created component.
*/
/**
* @template T
* @param {?} portal
* @return {?}
*/
attachComponentPortal(portal) {
/** @type {?} */
const resolver = portal.cfr || this.componentFactoryResolver;
/** @type {?} */
const componentFactory = resolver.resolveComponentFactory(portal.component);
/** @type {?} */
let componentRef;
// If the portal specifies a ViewContainerRef, we will use that as the attachment point
// for the component (in terms of Angular's component tree, not rendering).
// When the ViewContainerRef is missing, we use the factory to create the component directly
// and then manually attach the view to the application.
if (portal.viewContainerRef) {
componentRef = portal.viewContainerRef.createComponent(componentFactory, portal.viewContainerRef.length, portal.injector || portal.viewContainerRef.parentInjector);
this.setDisposeFn(() => componentRef.destroy());
}
else {
componentRef = componentFactory.create(portal.injector || this.defaultInjector);
this.appRef.attachView(componentRef.hostView);
this.setDisposeFn(() => {
this.appRef.detachView(componentRef.hostView);
componentRef.destroy();
});
}
// At this point the component has been instantiated, so we move it to the location in the DOM
// where we want it to be rendered.
this.outletElement.appendChild(this.getComponentRootNode(componentRef));
return componentRef;
}
/* Gets the root HTMLElement for an instantiated component. */
/**
* @private
* @param {?} componentRef
* @return {?}
*/
getComponentRootNode(componentRef) {
return (/** @type {?} */ (((/** @type {?} */ (componentRef.hostView))).rootNodes[0]));
}
}
if (false) {
/** @type {?} */
NbDomPortalOutlet.prototype.outletElement;
/**
* @type {?}
* @private
*/
NbDomPortalOutlet.prototype.componentFactoryResolver;
/**
* @type {?}
* @private
*/
NbDomPortalOutlet.prototype.appRef;
/**
* @type {?}
* @private
*/
NbDomPortalOutlet.prototype.defaultInjector;
}
export class NbOverlay extends Overlay {
/**
* @param {?} scrollStrategies
* @param {?} overlayContainer
* @param {?} componentFactoryResolver
* @param {?} positionBuilder
* @param {?} keyboardDispatcher
* @param {?} injector
* @param {?} ngZone
* @param {?} document
* @param {?} directionality
*/
constructor(scrollStrategies, overlayContainer, componentFactoryResolver, positionBuilder, keyboardDispatcher, injector, ngZone, document, directionality) {
super(scrollStrategies, overlayContainer, componentFactoryResolver, positionBuilder, keyboardDispatcher, injector, ngZone, document, directionality);
this.scrollStrategies = scrollStrategies;
this.overlayContainer = overlayContainer;
this.componentFactoryResolver = componentFactoryResolver;
this.positionBuilder = positionBuilder;
this.keyboardDispatcher = keyboardDispatcher;
this.injector = injector;
this.ngZone = ngZone;
this.document = document;
this.directionality = directionality;
}
/*
* Creates an overlay.
* @param config Configuration applied to the overlay.
* @returns Reference to the created overlay.
*/
/**
* @param {?=} config
* @return {?}
*/
create(config) {
/** @type {?} */
const host = this.createHostElement();
/** @type {?} */
const pane = this.createPaneElement(host);
/** @type {?} */
const portalOutlet = this.createPortalOutlet(pane);
/** @type {?} */
const overlayConfig = new OverlayConfig(config);
overlayConfig.direction = overlayConfig.direction || this.directionality.value;
return new OverlayRef(portalOutlet, host, pane, overlayConfig, this.ngZone, this.keyboardDispatcher, this.document);
}
/*
* Creates the DOM element for an overlay and appends it to the overlay container.
* @returns Newly-created pane element
*/
/**
* @protected
* @param {?} host
* @return {?}
*/
createPaneElement(host) {
/** @type {?} */
const pane = this.document.createElement('div');
pane.id = `cdk-overlay-${NbOverlay.nextUniqueId++}`;
pane.classList.add('cdk-overlay-pane');
host.appendChild(pane);
return pane;
}
/*
* Creates the host element that wraps around an overlay
* and can be used for advanced positioning.
* @returns Newly-create host element.
*/
/**
* @protected
* @return {?}
*/
createHostElement() {
/** @type {?} */
const host = this.document.createElement('div');
this.overlayContainer.getContainerElement().appendChild(host);
return host;
}
/*
* Create a DomPortalOutlet into which the overlay content can be loaded.
* @param pane The DOM element to turn into a portal outlet.
* @returns A portal outlet for the given DOM element.
*/
/**
* @protected
* @param {?} pane
* @return {?}
*/
createPortalOutlet(pane) {
// We have to resolve the ApplicationRef later in order to allow people
// to use overlay-based providers during app initialization.
if (!this.appRef) {
this.appRef = this.injector.get(ApplicationRef);
}
return new NbDomPortalOutlet(pane, this.componentFactoryResolver, this.appRef, this.injector);
}
}
NbOverlay.nextUniqueId = 0;
NbOverlay.decorators = [
{ type: Injectable }
];
/** @nocollapse */
NbOverlay.ctorParameters = () => [
{ type: ScrollStrategyOptions },
{ type: OverlayContainer },
{ type: ComponentFactoryResolver },
{ type: OverlayPositionBuilder },
{ type: OverlayKeyboardDispatcher },
{ type: Injector },
{ type: NgZone },
{ type: undefined, decorators: [{ type: Inject, args: [NB_DOCUMENT,] }] },
{ type: Directionality }
];
if (false) {
/**
* @type {?}
* @protected
*/
NbOverlay.nextUniqueId;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.appRef;
/** @type {?} */
NbOverlay.prototype.scrollStrategies;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.overlayContainer;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.componentFactoryResolver;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.positionBuilder;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.keyboardDispatcher;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.injector;
/**
* @type {?}
* @protected
*/
NbOverlay.prototype.ngZone;
/**
* @type {?}
* @private
*/
NbOverlay.prototype.document;
/**
* @type {?}
* @private
*/
NbOverlay.prototype.directionality;
}
export class NbPlatform extends Platform {
}
NbPlatform.decorators = [
{ type: Injectable }
];
export class NbOverlayPositionBuilder extends OverlayPositionBuilder {
}
NbOverlayPositionBuilder.decorators = [
{ type: Injectable }
];
/**
* @template T
*/
export class NbTemplatePortal extends TemplatePortal {
/**
* @param {?} template
* @param {?=} viewContainerRef
* @param {?=} context
*/
constructor(template, viewContainerRef, context) {
super(template, viewContainerRef, context);
}
}
export class NbOverlayContainer extends OverlayContainer {
}
/** @nocollapse */ NbOverlayContainer.ngInjectableDef = i0.defineInjectable({ factory: function NbOverlayContainer_Factory() { return new NbOverlayContainer(i0.inject(i1.DOCUMENT)); }, token: NbOverlayContainer, providedIn: "root" });
export class NbFlexibleConnectedPositionStrategy extends FlexibleConnectedPositionStrategy {
}
export class NbPortalInjector extends PortalInjector {
}
/** @type {?} */
const CDK_MODULES = [OverlayModule, PortalModule];
/*
* This module helps us to keep all angular/cdk deps inside our cdk module via providing aliases.
* Approach will help us move cdk in separate npm package and refactor nebular/theme code.
* */
export class NbCdkMappingModule {
/**
* @return {?}
*/
static forRoot() {
return (/** @type {?} */ ({
ngModule: NbCdkMappingModule,
providers: [
NbOverlay,
NbPlatform,
NbOverlayPositionBuilder,
],
}));
}
}
NbCdkMappingModule.decorators = [
{ type: NgModule, args: [{
imports: [...CDK_MODULES],
exports: [
...CDK_MODULES,
NbPortalDirective,
NbPortalOutletDirective,
],
declarations: [NbPortalDirective, NbPortalOutletDirective],
},] }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mapping.js","sourceRoot":"ng://theme-lib/","sources":["lib/components/cdk/overlay/mapping.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ApplicationRef,\r\n  ComponentFactoryResolver,\r\n  ComponentRef,\r\n  Directive,\r\n  EmbeddedViewRef,\r\n  Inject,\r\n  Injectable,\r\n  Injector,\r\n  ModuleWithProviders,\r\n  NgModule,\r\n  NgZone,\r\n  TemplateRef,\r\n  ViewContainerRef,\r\n} from '@angular/core';\r\nimport {\r\n  CdkPortal,\r\n  CdkPortalOutlet,\r\n  ComponentPortal,\r\n  DomPortalOutlet,\r\n  Portal,\r\n  PortalInjector,\r\n  PortalModule,\r\n  TemplatePortal,\r\n} from '@angular/cdk/portal';\r\nimport {\r\n  ComponentType,\r\n  ConnectedOverlayPositionChange,\r\n  ConnectedPosition,\r\n  ConnectionPositionPair,\r\n  FlexibleConnectedPositionStrategy,\r\n  Overlay,\r\n  OverlayConfig,\r\n  OverlayContainer,\r\n  OverlayKeyboardDispatcher,\r\n  OverlayModule,\r\n  OverlayPositionBuilder,\r\n  OverlayRef,\r\n  PositionStrategy,\r\n  ScrollStrategy,\r\n  ScrollStrategyOptions,\r\n} from '@angular/cdk/overlay';\r\nimport { Platform } from '@angular/cdk/platform';\r\nimport { Directionality } from '@angular/cdk/bidi';\r\n\r\nimport { NB_DOCUMENT } from '../../../theme.options';\r\n\r\n\r\n@Directive({ selector: '[nbPortal]' })\r\nexport class NbPortalDirective extends CdkPortal {\r\n}\r\n\r\n@Directive({ selector: '[nbPortalOutlet]' })\r\nexport class NbPortalOutletDirective extends CdkPortalOutlet {\r\n}\r\n\r\nexport class NbComponentPortal<T = any> extends ComponentPortal<T> {\r\n  constructor(component: ComponentType<T>,\r\n              vcr?: ViewContainerRef,\r\n              injector?: Injector,\r\n              public cfr?: ComponentFactoryResolver) {\r\n    super(component, vcr, injector);\r\n  }\r\n}\r\n\r\n/*\r\n * TODO remove after @angular/cdk@7.0.0 relased\r\n * */\r\nexport class NbDomPortalOutlet extends DomPortalOutlet {\r\n  constructor(\r\n    /* Element into which the content is projected. */\r\n    public outletElement: Element,\r\n    private componentFactoryResolver: ComponentFactoryResolver,\r\n    private appRef: ApplicationRef,\r\n    private defaultInjector: Injector) {\r\n    super(outletElement, componentFactoryResolver, appRef, defaultInjector);\r\n  }\r\n\r\n  /*\r\n   * Attach the given ComponentPortal to DOM element using the ComponentFactoryResolver.\r\n   * @param portal Portal to be attached\r\n   * @returns Reference to the created component.\r\n   */\r\n  attachComponentPortal<T>(portal: NbComponentPortal<T>): ComponentRef<T> {\r\n    const resolver = portal.cfr || this.componentFactoryResolver;\r\n    const componentFactory = resolver.resolveComponentFactory(portal.component);\r\n    let componentRef: ComponentRef<T>;\r\n\r\n    // If the portal specifies a ViewContainerRef, we will use that as the attachment point\r\n    // for the component (in terms of Angular's component tree, not rendering).\r\n    // When the ViewContainerRef is missing, we use the factory to create the component directly\r\n    // and then manually attach the view to the application.\r\n    if (portal.viewContainerRef) {\r\n      componentRef = portal.viewContainerRef.createComponent(\r\n        componentFactory,\r\n        portal.viewContainerRef.length,\r\n        portal.injector || portal.viewContainerRef.parentInjector);\r\n\r\n      this.setDisposeFn(() => componentRef.destroy());\r\n    } else {\r\n      componentRef = componentFactory.create(portal.injector || this.defaultInjector);\r\n      this.appRef.attachView(componentRef.hostView);\r\n      this.setDisposeFn(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n        componentRef.destroy();\r\n      });\r\n    }\r\n    // At this point the component has been instantiated, so we move it to the location in the DOM\r\n    // where we want it to be rendered.\r\n    this.outletElement.appendChild(this.getComponentRootNode(componentRef));\r\n\r\n    return componentRef;\r\n  }\r\n\r\n  /* Gets the root HTMLElement for an instantiated component. */\r\n  private getComponentRootNode(componentRef: ComponentRef<any>): HTMLElement {\r\n    return (componentRef.hostView as EmbeddedViewRef<any>).rootNodes[0] as HTMLElement;\r\n  }\r\n}\r\n\r\n@Injectable()\r\nexport class NbOverlay extends Overlay {\r\n  protected appRef: ApplicationRef;\r\n  protected static nextUniqueId = 0;\r\n\r\n  constructor(\r\n    /* Scrolling strategies that can be used when creating an overlay. */\r\n    public scrollStrategies: ScrollStrategyOptions,\r\n    protected overlayContainer: OverlayContainer,\r\n    protected componentFactoryResolver: ComponentFactoryResolver,\r\n    protected positionBuilder: OverlayPositionBuilder,\r\n    protected keyboardDispatcher: OverlayKeyboardDispatcher,\r\n    protected injector: Injector,\r\n    protected ngZone: NgZone,\r\n    @Inject(NB_DOCUMENT) private document: any,\r\n    private directionality: Directionality) {\r\n    super(\r\n      scrollStrategies,\r\n      overlayContainer,\r\n      componentFactoryResolver,\r\n      positionBuilder,\r\n      keyboardDispatcher,\r\n      injector,\r\n      ngZone,\r\n      document,\r\n      directionality,\r\n    );\r\n  }\r\n\r\n  /*\r\n   * Creates an overlay.\r\n   * @param config Configuration applied to the overlay.\r\n   * @returns Reference to the created overlay.\r\n   */\r\n  create(config?: OverlayConfig): OverlayRef {\r\n    const host = this.createHostElement();\r\n    const pane = this.createPaneElement(host);\r\n    const portalOutlet = this.createPortalOutlet(pane);\r\n    const overlayConfig = new OverlayConfig(config);\r\n\r\n    overlayConfig.direction = overlayConfig.direction || this.directionality.value;\r\n\r\n    return new OverlayRef(portalOutlet, host, pane, overlayConfig, this.ngZone,\r\n      this.keyboardDispatcher, this.document);\r\n  }\r\n\r\n  /*\r\n   * Creates the DOM element for an overlay and appends it to the overlay container.\r\n   * @returns Newly-created pane element\r\n   */\r\n  protected createPaneElement(host: HTMLElement): HTMLElement {\r\n    const pane = this.document.createElement('div');\r\n\r\n    pane.id = `cdk-overlay-${NbOverlay.nextUniqueId++}`;\r\n    pane.classList.add('cdk-overlay-pane');\r\n    host.appendChild(pane);\r\n\r\n    return pane;\r\n  }\r\n\r\n  /*\r\n   * Creates the host element that wraps around an overlay\r\n   * and can be used for advanced positioning.\r\n   * @returns Newly-create host element.\r\n   */\r\n  protected createHostElement(): HTMLElement {\r\n    const host = this.document.createElement('div');\r\n    this.overlayContainer.getContainerElement().appendChild(host);\r\n    return host;\r\n  }\r\n\r\n  /*\r\n   * Create a DomPortalOutlet into which the overlay content can be loaded.\r\n   * @param pane The DOM element to turn into a portal outlet.\r\n   * @returns A portal outlet for the given DOM element.\r\n   */\r\n  protected createPortalOutlet(pane: HTMLElement): NbDomPortalOutlet {\r\n    // We have to resolve the ApplicationRef later in order to allow people\r\n    // to use overlay-based providers during app initialization.\r\n    if (!this.appRef) {\r\n      this.appRef = this.injector.get<ApplicationRef>(ApplicationRef);\r\n    }\r\n\r\n    return new NbDomPortalOutlet(pane, this.componentFactoryResolver, this.appRef, this.injector);\r\n  }\r\n}\r\n\r\n@Injectable()\r\nexport class NbPlatform extends Platform {\r\n}\r\n\r\n@Injectable()\r\nexport class NbOverlayPositionBuilder extends OverlayPositionBuilder {\r\n}\r\n\r\nexport class NbTemplatePortal<T = any> extends TemplatePortal<T> {\r\n  constructor(template: TemplateRef<T>, viewContainerRef?: ViewContainerRef, context?: T) {\r\n    super(template, viewContainerRef, context);\r\n  }\r\n}\r\n\r\nexport class NbOverlayContainer extends OverlayContainer {\r\n}\r\n\r\nexport class NbFlexibleConnectedPositionStrategy extends FlexibleConnectedPositionStrategy {\r\n}\r\n\r\nexport class NbPortalInjector extends PortalInjector {\r\n}\r\n\r\nexport type NbPortal<T = any> = Portal<T>;\r\nexport type NbOverlayRef = OverlayRef;\r\nexport type NbComponentType<T = any> = ComponentType<T>;\r\nexport type NbPositionStrategy = PositionStrategy;\r\nexport type NbConnectedPosition = ConnectedPosition;\r\nexport type NbConnectedOverlayPositionChange = ConnectedOverlayPositionChange;\r\nexport type NbConnectionPositionPair = ConnectionPositionPair;\r\nexport type NbOverlayConfig = OverlayConfig;\r\nexport type NbScrollStrategyOptions = ScrollStrategyOptions;\r\nexport type NbScrollStrategy = ScrollStrategy;\r\n\r\nconst CDK_MODULES = [OverlayModule, PortalModule];\r\n\r\n/*\r\n * This module helps us to keep all angular/cdk deps inside our cdk module via providing aliases.\r\n * Approach will help us move cdk in separate npm package and refactor nebular/theme code.\r\n * */\r\n@NgModule({\r\n  imports: [...CDK_MODULES],\r\n  exports: [\r\n    ...CDK_MODULES,\r\n    NbPortalDirective,\r\n    NbPortalOutletDirective,\r\n  ],\r\n  declarations: [NbPortalDirective, NbPortalOutletDirective],\r\n})\r\nexport class NbCdkMappingModule {\r\n  static forRoot(): ModuleWithProviders {\r\n    return <ModuleWithProviders> {\r\n      ngModule: NbCdkMappingModule,\r\n      providers: [\r\n        NbOverlay,\r\n        NbPlatform,\r\n        NbOverlayPositionBuilder,\r\n      ],\r\n    };\r\n  }\r\n}\r\n"]}