novo-elements 11.4.0 → 12.0.0

package/elements/menu/index.d.ts

@@ -1,8 +1,202 @@
-export * from './menu-content.component';
-export * from './menu-item.directive';
-export * from './menu.component';
-export * from './menu.directive';
-export { NovoMenuModule } from './menu.module';
-export * from './menu.service';
-export * from './menu.tokens';
-export * from './menu.types';
+import * as i6 from '@angular/cdk/overlay';
+import { Overlay, ScrollStrategyOptions, OverlayRef } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { TemplateRef, ElementRef, OnDestroy, EventEmitter, QueryList, ChangeDetectorRef, OnInit, AfterViewInit, ModuleWithProviders, InjectionToken } from '@angular/core';
+import * as i7 from 'novo-elements/elements/common';
+import { NovoOption } from 'novo-elements/elements/common';
+import { Subscription, Subject } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i8 from 'novo-elements/elements/icon';
+
+/**
+ * This is a structural directive now.  Should only be used on `novo-options`
+ */
+declare class MenuItemDirective {
+    template: TemplateRef<{
+        item: any;
+    }>;
+    elementRef: ElementRef;
+    menuItemEnabled: boolean | ((item: any) => boolean);
+    menuItemVisible: boolean | ((item: any) => boolean);
+    optionRef: NovoOption;
+    currentItem: any;
+    constructor(template: TemplateRef<{
+        item: any;
+    }>, elementRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuItemDirective, "[menuItem]", never, { "menuItemEnabled": { "alias": "menuItemEnabled"; "required": false; }; "menuItemVisible": { "alias": "menuItemVisible"; "required": false; }; }, {}, ["optionRef"], never, false, never>;
+}
+
+interface IMenuOptions {
+    autoFocus?: boolean;
+}
+interface ILinkConfig {
+    click: (item: any, $event?: MouseEvent) => void;
+    enabled?: (item: any) => boolean;
+    html: (item: any) => string;
+}
+
+interface MouseLocation {
+    left?: string;
+    marginLeft?: string;
+    marginTop?: string;
+    top?: string;
+}
+declare class MenuComponent implements OnDestroy {
+    private menuService;
+    private changeDetector;
+    private elementRef;
+    private options;
+    menuClass: string;
+    autoFocus: boolean;
+    disabled: boolean;
+    close: EventEmitter<CloseMenuEvent>;
+    open: EventEmitter<IMenuClickEvent>;
+    menuItems: QueryList<MenuItemDirective>;
+    menuOptions: QueryList<NovoOption>;
+    menuElement: ElementRef;
+    visibleMenuItems: MenuItemDirective[];
+    links: ILinkConfig[];
+    item: any;
+    event: MouseEvent | KeyboardEvent;
+    private subscription;
+    constructor(menuService: NovoMenuService, changeDetector: ChangeDetectorRef, elementRef: ElementRef, options: IMenuOptions);
+    ngOnDestroy(): void;
+    onMenuEvent(menuEvent: IMenuClickEvent): void;
+    isMenuItemVisible(menuItem: MenuItemDirective): boolean;
+    setVisibleMenuItems(): void;
+    evaluateIfFunction(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "novo-menu", never, { "menuClass": { "alias": "menuClass"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "close": "close"; "open": "open"; }, ["menuItems", "menuOptions"], never, false, never>;
+}
+
+declare class MenuDirective implements OnInit, OnDestroy {
+    private element;
+    private menuService;
+    private cdr;
+    private _parentMenu;
+    menuContext: any;
+    menu: MenuComponent;
+    menuContent: MenuContentComponent;
+    waitWhenOpen: boolean;
+    capture: boolean;
+    anchor: boolean;
+    trigger: 'click' | 'contextmenu' | 'mouseenter';
+    isSubMenu: boolean;
+    isActive: boolean;
+    get hb_menuActive(): boolean;
+    subscription: Subscription;
+    constructor(element: ElementRef, menuService: NovoMenuService, cdr: ChangeDetectorRef, _parentMenu: MenuComponent);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onMenuClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDirective, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuDirective, "[menu]", never, { "menuContext": { "alias": "menuContext"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "menuContent": { "alias": "menuContent"; "required": false; }; "waitWhenOpen": { "alias": "waitWhenOpen"; "required": false; }; "capture": { "alias": "capture"; "required": false; }; "anchor": { "alias": "anchor"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface IMenuClickEvent {
+    anchorElement?: Element | EventTarget;
+    menu?: MenuComponent;
+    event?: MouseEvent | KeyboardEvent;
+    parentMenu?: MenuComponent;
+    menuTrigger?: MenuDirective;
+    item: any;
+    activeMenuItemIndex?: number;
+}
+interface IMenuContext extends IMenuClickEvent {
+    menuItems: MenuItemDirective[];
+    menuClass: string;
+}
+interface CloseLeafMenuEvent {
+    exceptRootMenu?: boolean;
+    event?: MouseEvent | KeyboardEvent;
+}
+interface OverlayRefWithMenu extends OverlayRef {
+    menu?: MenuContentComponent;
+}
+interface CancelMenuEvent {
+    eventType: 'cancel';
+    event?: MouseEvent | KeyboardEvent;
+}
+interface ExecuteMenuEvent {
+    eventType: 'execute';
+    event?: MouseEvent | KeyboardEvent;
+    item: any;
+    menuItem: MenuItemDirective;
+}
+type CloseMenuEvent = ExecuteMenuEvent | CancelMenuEvent;
+declare class NovoMenuService {
+    private overlay;
+    private scrollStrategy;
+    isDestroyingLeafMenu: boolean;
+    show: Subject<IMenuClickEvent>;
+    triggerClose: Subject<MenuContentComponent>;
+    close: Subject<CloseMenuEvent>;
+    private menuContent;
+    private overlays;
+    private fakeElement;
+    constructor(overlay: Overlay, scrollStrategy: ScrollStrategyOptions);
+    openMenu(context: IMenuContext): void;
+    attachMenu(overlay: OverlayRef, context: IMenuContext): void;
+    closeAllMenus(closeEvent: CloseMenuEvent): void;
+    hasOpenMenus(): boolean;
+    getLastAttachedOverlay(): OverlayRefWithMenu;
+    destroyLeafMenu({ exceptRootMenu, event }?: CloseLeafMenuEvent): void;
+    destroySubMenus(menu: MenuContentComponent): void;
+    isLeafMenu(menuContent: MenuContentComponent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NovoMenuService>;
+}
+
+declare class MenuContentComponent implements OnInit, OnDestroy, AfterViewInit {
+    menuItems: MenuItemDirective[];
+    item: any;
+    event: MouseEvent | KeyboardEvent;
+    menu: any;
+    parentMenu: MenuContentComponent;
+    menuClass: string;
+    overlay: OverlayRef;
+    isLeaf: boolean;
+    openSubMenu: EventEmitter<IMenuClickEvent>;
+    closeLeafMenu: EventEmitter<CloseLeafMenuEvent>;
+    closeAllMenus: EventEmitter<{
+        event: MouseEvent;
+    }>;
+    autoFocus: boolean;
+    private _keyManager;
+    private subscription;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    stopEvent($event: MouseEvent): void;
+    isMenuItemEnabled(menuItem: MenuItemDirective): boolean;
+    isMenuItemVisible(menuItem: MenuItemDirective): boolean;
+    evaluateIfFunction(value: any): any;
+    isDisabled(link: ILinkConfig): boolean;
+    onKeyEvent(event: KeyboardEvent): void;
+    keyboardOpenSubMenu(event?: KeyboardEvent): void;
+    keyboardMenuItemSelect(event?: KeyboardEvent): void;
+    onCloseLeafMenu(event: KeyboardEvent): void;
+    closeMenu(event: MouseEvent): void;
+    onMouseLeave(event: MouseEvent): void;
+    onOpenSubMenu(menuItem: MenuItemDirective, event?: MouseEvent | KeyboardEvent): void;
+    onMenuItemSelect(menuItem: MenuItemDirective, event: MouseEvent | KeyboardEvent): void;
+    private cancelEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuContentComponent, "menu-content", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "item": { "alias": "item"; "required": false; }; "event": { "alias": "event"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "parentMenu": { "alias": "parentMenu"; "required": false; }; "menuClass": { "alias": "menuClass"; "required": false; }; "overlay": { "alias": "overlay"; "required": false; }; "isLeaf": { "alias": "isLeaf"; "required": false; }; }, { "openSubMenu": "openSubMenu"; "closeLeafMenu": "closeLeafMenu"; "closeAllMenus": "closeAllMenus"; }, never, never, false, never>;
+}
+
+declare class NovoMenuModule {
+    static forRoot(options?: IMenuOptions): ModuleWithProviders<NovoMenuModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoMenuModule, [typeof MenuDirective, typeof MenuComponent, typeof MenuContentComponent, typeof MenuItemDirective], [typeof i5.CommonModule, typeof i6.OverlayModule, typeof i7.NovoCommonModule, typeof i8.NovoIconModule], [typeof MenuDirective, typeof MenuComponent, typeof MenuItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoMenuModule>;
+}
+
+declare const MENU_OPTIONS: InjectionToken<unknown>;
+declare const PARENT_MENU: InjectionToken<unknown>;
+
+export { MENU_OPTIONS, MenuComponent, MenuContentComponent, MenuDirective, MenuItemDirective, NovoMenuModule, NovoMenuService, PARENT_MENU };
+export type { CancelMenuEvent, CloseLeafMenuEvent, CloseMenuEvent, ExecuteMenuEvent, ILinkConfig, IMenuClickEvent, IMenuContext, IMenuOptions, MouseLocation, OverlayRefWithMenu };

package/elements/modal/index.d.ts

@@ -1,6 +1,96 @@
-export * from './modal-container.component';
-export * from './modal-ref';
-export * from './modal.animation';
-export * from './modal.component';
-export * from './modal.module';
-export * from './modal.service';
+import * as _angular_animations from '@angular/animations';
+import { AnimationEvent } from '@angular/animations';
+import * as i4 from '@angular/cdk/portal';
+import { Portal } from '@angular/cdk/portal';
+import * as i0 from '@angular/core';
+import { EventEmitter, Injector, OnInit, ViewContainerRef } from '@angular/core';
+import * as i3 from '@angular/cdk/overlay';
+import { OverlayRef, Overlay } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i6 from 'novo-elements/elements/button';
+
+/**
+ * Params that can be passed to the Modal
+ */
+interface ModalParams {
+    [propName: string]: any;
+}
+declare class NovoModalParams implements ModalParams {
+}
+declare class NovoModalRef<T = any, R = any> {
+    component: any;
+    params: T;
+    private overlayRef;
+    constructor(component: any, params: T, overlayRef: OverlayRef);
+    private _beforeClose;
+    private _afterClosed;
+    componentInstance: NovoModalContainerComponent;
+    isClosed: boolean;
+    get onClosed(): Promise<R>;
+    afterClosed(): Observable<R>;
+    beforeClose(): Observable<R>;
+    close(result?: R): void;
+}
+
+declare class NovoModalContainerComponent {
+    private injector;
+    private modalRef;
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    animationState: 'void' | 'enter' | 'leave';
+    component: Portal<any>;
+    initTimestamp: number;
+    id: string;
+    constructor(injector: Injector, modalRef: NovoModalRef);
+    onAnimationStart(event: AnimationEvent): void;
+    onAnimationDone(event: AnimationEvent): void;
+    startExitAnimation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoModalContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoModalContainerComponent, "novo-modal-container", never, {}, { "animationStateChanged": "animationStateChanged"; }, never, never, false, never>;
+}
+
+declare const zoomInOut: _angular_animations.AnimationTriggerMetadata;
+
+declare class NovoModalElement {
+    private modalRef;
+    constructor(modalRef: NovoModalRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoModalElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoModalElement, "novo-modal", never, {}, {}, never, ["header,novo-header,novo-card-header", "section,novo-card-content", "button,novo-button"], false, never>;
+}
+declare class NovoModalNotificationElement implements OnInit {
+    private modalRef;
+    type: string;
+    icon: string;
+    cancel: EventEmitter<any>;
+    iconType: string;
+    constructor(modalRef: NovoModalRef);
+    close(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoModalNotificationElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoModalNotificationElement, "novo-notification", never, { "type": { "alias": "type"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "cancel": "cancel"; }, never, ["label,novo-label", "h1", "h2", "p", "button,novo-button,novo-dropdown"], false, never>;
+}
+
+declare class NovoModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoModalModule, [typeof NovoModalContainerComponent, typeof NovoModalElement, typeof NovoModalNotificationElement], [typeof i3.OverlayModule, typeof i4.PortalModule, typeof i5.CommonModule, typeof i6.NovoButtonModule], [typeof NovoModalElement, typeof NovoModalNotificationElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoModalModule>;
+}
+
+declare class NovoModalService {
+    private injector;
+    private overlay;
+    _parentViewContainer: ViewContainerRef;
+    overlayRef: OverlayRef;
+    set parentViewContainer(view: ViewContainerRef);
+    constructor(injector: Injector, overlay: Overlay);
+    open<T extends Record<string, any>>(component: any, params?: Partial<T>): NovoModalRef<Partial<T>, any>;
+    private createOverlay;
+    private attachModalContainer;
+    private createInjector;
+    private getOverlayConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NovoModalService>;
+}
+
+export { NovoModalContainerComponent, NovoModalElement, NovoModalModule, NovoModalNotificationElement, NovoModalParams, NovoModalRef, NovoModalService, zoomInOut };
+export type { ModalParams };

package/elements/multi-picker/index.d.ts

@@ -1,2 +1,122 @@
-export * from './MultiPicker';
-export * from './MultiPicker.module';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, EventEmitter } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { NovoLabelService } from 'novo-elements/services';
+import * as i2 from '@angular/common';
+import * as i3 from '@angular/forms';
+import * as i4 from 'novo-elements/elements/picker';
+import * as i5 from 'novo-elements/elements/chips';
+
+interface Item {
+    type: any;
+    label: any;
+    value: any;
+}
+declare class NovoMultiPickerElement implements OnInit {
+    element: ElementRef;
+    labels: NovoLabelService;
+    source: {
+        options: [];
+        resultsTemplate: any;
+        selectAllOption: boolean;
+        chipsCount: any;
+        strictRelationship: any;
+    };
+    placeholder: any;
+    types: {
+        value: any;
+        singular: any;
+        plural: any;
+        isParentOf: any;
+        isChildOf: any;
+    }[];
+    changed: EventEmitter<any>;
+    focus: EventEmitter<any>;
+    blur: EventEmitter<any>;
+    get value(): {};
+    set value(selectedItems: {});
+    items: Item[];
+    _items: ReplaySubject<Item[]>;
+    options: any;
+    _options: any;
+    selected: any;
+    config: any;
+    chipsCount: number;
+    selectAllOption: boolean;
+    strictRelationship: boolean;
+    _value: {};
+    notShown: any;
+    model: any;
+    onModelChange: Function;
+    onModelTouched: Function;
+    constructor(element: ElementRef, labels: NovoLabelService);
+    ngOnInit(): void;
+    clearValue(): void;
+    removeFromDisplay(event: any, item: any): void;
+    setupOptions(): void;
+    setupOptionsByType(section: any): any;
+    formatOption(section: any, item: any): {
+        value: any;
+        label: any;
+        type: any;
+        checked: any;
+        isParentOf: any;
+        isChildOf: any;
+    };
+    createSelectAllOption(section: any): {
+        value: string;
+        label: string;
+        type: any;
+        checked: boolean;
+        isParentOf: any;
+        isChildOf: any;
+    };
+    deselectAll(): void;
+    select(event: any, item: any): void;
+    onFocus(e: any): void;
+    clickOption(event: any): void;
+    add(event: any): void;
+    updateAllItemState(type: any): {
+        allOfType: any;
+        allOfTypeSelected: boolean;
+    };
+    setIndeterminateState(allOfType: any, status: any): void;
+    updateDisplayItems(item: any, action: any): void;
+    updateDisplayText(items: any): void;
+    remove(event: any, item: any): void;
+    removeItem(item: any, triggeredByEvent?: any): void;
+    removeValue(item: any): void;
+    onKeyDown(event: any): void;
+    allOfTypeSelected(type: any): boolean;
+    modifyAllOfType(type: any, action: any): void;
+    triggerValueUpdate(): void;
+    selectAll(allOfType: any, type: any): void;
+    handleRemoveItemIfAllSelected(item: any): void;
+    handleOutsideClick(event: any): void;
+    getAllOfType(type: any): any;
+    updateParentOrChildren(item: any, action: any): void;
+    modifyAffectedParentsOrChildren(selecting: any, itemChanged: any): void;
+    updateAllParentsOrChildren(allItem: any, action: any): void;
+    updateAllChildrenValue(item: any, action: any): void;
+    updateAllParentValue(item: any, action: any): void;
+    updateIndeterminateStates(allParentType: any, allChildren: any, allCheckedChildren: any): void;
+    updateChildrenValue(parent: any, action: any): void;
+    updateParentValue(child: any, action: any): void;
+    addIndividualChildren(children: any): void;
+    setInitialValue(model: any): void;
+    allItemsSelected(optionsByType: any, type: any): boolean;
+    onTouched(e: any): void;
+    writeValue(model: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoMultiPickerElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NovoMultiPickerElement, "multi-picker", never, { "source": { "alias": "source"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "types": { "alias": "types"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "changed": "changed"; "focus": "focus"; "blur": "blur"; }, never, never, false, never>;
+}
+
+declare class NovoMultiPickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoMultiPickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoMultiPickerModule, [typeof NovoMultiPickerElement], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.NovoPickerModule, typeof i5.NovoChipsModule], [typeof NovoMultiPickerElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoMultiPickerModule>;
+}
+
+export { NovoMultiPickerElement, NovoMultiPickerModule };

package/elements/non-ideal-state/index.d.ts

@@ -1,2 +1,22 @@
-export * from './NonIdealState';
-export * from './NonIdealState.module';
+import * as i0 from '@angular/core';
+import * as i2 from '@angular/common';
+import * as i3 from 'novo-elements/elements/icon';
+import * as i4 from 'novo-elements/elements/common';
+
+declare class NonIdealStateElement {
+    hb_class: string;
+    theme: string;
+    icon: string;
+    title: string;
+    description: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NonIdealStateElement, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NonIdealStateElement, "novo-non-ideal-state", never, { "theme": { "alias": "theme"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; }, {}, never, ["novo-icon", "novo-icon,novo-loading,novo-avatar", "novo-title", "novo-text", "*"], false, never>;
+}
+
+declare class NovoNonIdealStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NovoNonIdealStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NovoNonIdealStateModule, [typeof NonIdealStateElement], [typeof i2.CommonModule, typeof i3.NovoIconModule, typeof i4.NovoCommonModule], [typeof NonIdealStateElement]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NovoNonIdealStateModule>;
+}
+
+export { NonIdealStateElement, NovoNonIdealStateModule };