@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/base/utils/widget-utils.d.ts

@@ -0,0 +1,120 @@
+import { NavNode } from "../widgets/common/base/dataset-aware-nav.component";
+/**
+ * Returns the value for the provided key in the object
+ */
+export declare const getObjValueByKey: (obj: any, strKey: string) => any;
+/**
+ * returns the display field data for any dataset widgets
+ * Based on the bind display expression or display expression or display name,
+ * data is extracted and formatted from the passed option object
+ * If there is field is specified, field value is obtained from the dataObj.
+ * If expression is given, evaluates the expression value.
+ * else check for bindExpression, extract the value from the dataObj
+ */
+export declare const getEvaluatedData: (dataObj: any, options: any, context?: any) => any;
+export declare const isActiveNavItem: (link: any, routeName: any) => boolean;
+/**
+* returns true if the menu has link to the current page.
+* @param nodes
+* @param routeUrl
+*/
+export declare const hasLinkToCurrentPage: (nodes: Array<NavNode>, routeUrl: any) => any;
+/**
+ * Returns the orderBy Expression based on the 'sort 'option in pageable object
+ * returned by backend
+ * @param pageableObj
+ * @returns {string}
+ */
+export declare const getOrderByExpr: (pageableObj: any) => string;
+export declare const isDataSetWidget: (widget: any) => boolean;
+export declare const getImageUrl: (urlString: any, shouldEncode?: any, defaultUrl?: any) => any;
+export declare const getBackGroundImageUrl: (urlString: any) => any;
+export declare function provideAs(reference: any, key: any, multi?: boolean): {
+    provide: any;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare function provideAsWidgetRef(reference: any): {
+    provide: any;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare function provideAsDialogRef(reference: any): {
+    provide: any;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare const NAVIGATION_TYPE: {
+    ADVANCED: string;
+    BASIC: string;
+    CLASSIC: string;
+    INLINE: string;
+    NONE: string;
+    ONDEMAND: string;
+    PAGER: string;
+    SCROLL: string;
+};
+export declare const INPUTMODE: {
+    FINANCIAL: string;
+    NATURAL: string;
+};
+export declare const AUTOCLOSE_TYPE: {
+    OUTSIDECLICK: string;
+    ALWAYS: string;
+    DISABLED: string;
+};
+export declare const unsupportedStatePersistenceTypes: string[];
+export declare const getWatchIdentifier: (...args: any[]) => string;
+export declare const getMatchModeTypesMap: (multiMode?: any) => {
+    boolean: string[];
+    clob: any[];
+    blob: any[];
+};
+export declare const getMatchModeMsgs: (appLocale: any) => {
+    start: any;
+    startignorecase: any;
+    end: any;
+    endignorecase: any;
+    anywhere: any;
+    anywhereignorecase: any;
+    exact: any;
+    exactignorecase: any;
+    notequals: any;
+    notequalsignorecase: any;
+    lessthan: any;
+    lessthanequal: any;
+    greaterthan: any;
+    greaterthanequal: any;
+    null: any;
+    isnotnull: any;
+    empty: any;
+    isnotempty: any;
+    nullorempty: any;
+    in: any;
+    notin: any;
+    between: any;
+};
+export declare const getConditionalClasses: (nv: any, ov?: any) => {
+    toAdd: any;
+    toRemove: any;
+};
+export declare const prepareFieldDefs: (data: any, options?: any) => any[] | {
+    objects: any[];
+    terminals: any[];
+};
+/**
+ * To get container target element to append the list for search and datepicker panel when field present in dialog
+ */
+export declare const getContainerTargetClass: (element: any) => string;
+/**
+ * To extract the Variable Name from a Widget's binddatasource attribute
+ */
+export declare const extractDataSourceName: (bindDataSource: any) => any;
+export declare const setFocusTrap: (container: any, allowOutsideClick: any, setReturnFocusElement?: any) => import("@wavemaker/focus-trap").FocusTrap;
+/**
+ * Gets keyboard focusable elements within a specified element
+ * @param element {HTMLElement}
+ * @returns {Array}
+ */
+export declare const getKeyboardFocusableElements: (element: HTMLElement) => Element[];
+export declare const getCurrentWidgets: (element: any, widgets: any) => any;

package/components/base/widgets/common/base/base-container.component.d.ts

@@ -0,0 +1,16 @@
+import { Injector, OnDestroy } from '@angular/core';
+import { StylableComponent } from "./stylable.component";
+import { IWidgetConfig } from '../../framework/types';
+import * as i0 from "@angular/core";
+export declare abstract class BaseContainerComponent extends StylableComponent implements OnDestroy {
+    reDrawableComponents: any;
+    content: any;
+    Widgets: any;
+    constructor(inj: Injector, WIDGET_CONFIG: IWidgetConfig, explicitContext: any);
+    private updateRedrawableComponents;
+    private redrawChildren;
+    onPropertyChange(key: string, nv: any, ov?: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseContainerComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseContainerComponent, never, never, {}, {}, ["reDrawableComponents"], never, false, never>;
+}

package/components/base/widgets/common/base/base-field-validations.d.ts

@@ -0,0 +1,27 @@
+export declare class BaseFieldValidations {
+    private hasValidators;
+    private instance;
+    formwidget: any;
+    private widgettype;
+    private widgetControl;
+    private widgetContext;
+    private tableFieldType;
+    private defaultValidatorMessages;
+    private _syncValidators;
+    private _asyncValidatorFn;
+    constructor(instance: any, formwidget: any, widgettype: any, widgetControl: any, widgetContext: any, tableFieldType?: any);
+    private getDefaultValidators;
+    setUpValidators(customValidator?: any): void;
+    getPromiseList(validators: any): any[];
+    setAsyncValidators(validators: any): void;
+    isDefaultValidator(type: any): undefined;
+    setDefaultValidator(key: any, value: any): void;
+    setValidators(validators: any): void;
+    observeOn(fields: any, context: any): void;
+    validate(): void;
+    watchDefaultValidatorExpr(fn: any, key: any): void;
+    isNullOrEmptyOrFalsy(value: any): boolean;
+    applyDefaultValidators(): void;
+    setCustomValidationMessage(): void;
+    destroy(): void;
+}

package/components/base/widgets/common/base/base.component.d.ts

@@ -0,0 +1,276 @@
+import { AfterContentInit, AfterViewInit, Injector, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
+import { EventManager } from '@angular/platform-browser';
+import { App } from '@wm/core';
+import { ChangeListener, IWidgetConfig } from '../../framework/types';
+import * as i0 from "@angular/core";
+interface Child {
+    widget: any;
+    nativeElement: any;
+}
+export declare abstract class BaseComponent implements OnDestroy, OnInit, AfterViewInit, AfterContentInit {
+    protected inj: Injector;
+    /**
+     * unique identifier for the widget
+     */
+    readonly widgetId: any;
+    isDestroyed: boolean;
+    isAttached: boolean;
+    /**
+     * jQuery nativeElement reference of the component root
+     */
+    get $element(): any;
+    /**
+     * DOM node reference of the component root
+     */
+    readonly nativeElement: HTMLElement;
+    /**
+     * Type of the component
+     */
+    protected readonly widgetType: string;
+    /**
+     * Most of the cases it is same as widgetType
+     * for specific widgets like charts widgetType can be wm-chart where as the subtype can be wm-bar-chart
+     */
+    protected readonly widgetSubType: string;
+    /**
+     * Proxy for the component instance.
+     */
+    protected widget: any;
+    /**
+     * View parent component
+     * eg, Page, Partial, Prefab
+     */
+    protected readonly viewParent: any;
+    /**
+     * EventManger to add/remove events
+     */
+    protected readonly eventManager: EventManager;
+    /**
+     * App Locale
+     */
+    readonly appLocale: any;
+    /**
+     * Style change subject and observable
+     */
+    private readonly styleChange;
+    /**
+     * Property change subject and observable
+     */
+    private readonly propertyChange;
+    /**
+     * On Ready State change subject and observable
+     */
+    private readonly readyState;
+    /**
+     * Component destroy subject and observable
+     */
+    private readonly destroy;
+    /**
+     * Map of event handler callbacks
+     */
+    private eventHandlers;
+    /**
+     * context of the widget
+     * when the widget is preset inside a repeater this context will have the repeater related properties
+     */
+    context: any;
+    /**
+     * Initial state of the widget.
+     * Will be undefined once the initial properties are set on to the component
+     */
+    private initState;
+    /**
+     * Internal flag to determine whether to wait for the widget initialization or not
+     * If the initPromise is provided in the construction wait till the promise is resolved
+     * If the initPromise is not provided proceed with the initialization, which is the default behavior.
+     */
+    private readonly delayedInit;
+    /**
+     * Display type of the component. eg, block(Default), inline-block, inline etc
+     */
+    private readonly displayType;
+    /**
+     * Holds the event registration functions.
+     * these functions needs to be executed after onViewInit
+     */
+    private toBeSetupEventsQueue;
+    __cloneable__: boolean;
+    widgetProps: Map<string, any>;
+    private $attrs;
+    private isMuted;
+    viewContainerRef: ViewContainerRef;
+    viewParentApp: App;
+    /**
+     * To avoid re-rendering of widget, passing unique id as contextKey to createCustomInjector
+     * (for List, Dynamic Tabs, Accordion, Nav, Carousel)
+     */
+    trackId: string;
+    customWidgetSubType: string;
+    protected constructor(inj: Injector, config: IWidgetConfig, explicitContext?: any, initPromise?: Promise<any>);
+    getNativeElement(): HTMLElement;
+    getWidgetType(): string;
+    getWidgetSubType(): string;
+    getWidget(): any;
+    setProperty(propName: any, propValue: any): void;
+    getViewParent(): any;
+    notifyStyleChange(key: string, nv: any, ov: any): void;
+    notifyPropertyChange(key: string, nv: any, ov: any): void;
+    registerStyleChangeListener(fn: ChangeListener, ctx?: any): void;
+    registerReadyStateListener(fn: Function, ctx?: any): void;
+    registerPropertyChangeListener(fn: ChangeListener, ctx?: any): void;
+    registerDestroyListener(fn: Function, ctx?: any): void;
+    getDisplayType(): string;
+    protected createProxy(): any;
+    protected initContext(): void;
+    /**
+     * set the value on the proxy object ie, widget
+     * setting the property on the proxy will invoke the change listeners
+     * @param {string} key
+     * @param value
+     */
+    setWidgetProperty(key: string, value: any): void;
+    getAttr(attrName: string): string;
+    /**
+     * returns app instance
+     * @returns {App}
+     */
+    getAppInstance(): App;
+    /**
+     * Generates a unique id
+     * Default pattern is `widget-id-${id}`
+     * Components can override this method to generate a different id eg, bar-chart-1
+     */
+    protected generateWidgetId(): string;
+    /**
+     * Handles the common functionality across the components
+     * eg,
+     *  1. value of the class property will be applied on the host element
+     *  2. based on the value of show property component is shown/hidden
+     *
+     * @param {string} key
+     * @param nv
+     * @param ov
+     */
+    protected onPropertyChange(key: string, nv: any, ov?: any): void;
+    /**
+     * Default style change handler
+     */
+    protected onStyleChange(k: string, nv: any, ov?: any): void;
+    /**
+     * Register the widget with the widgetRegistry
+     */
+    protected registerWidget(widgetName: string): void;
+    /**
+     * override the
+     */
+    protected getMappedEventName(eventName: any): any;
+    /**
+     * invoke the event handler
+     * Components can override this method to execute custom logic before invoking the user callback
+     */
+    protected handleEvent(node: HTMLElement, eventName: string, eventCallback: Function, locals: any, meta?: string): void;
+    /**
+     * parse the event expression and save reference to the function inside eventHandlers map
+     * If the component provides a override for an event through @Event decorator invoke that
+     * else invoke the resolved function
+     *
+     * @param {string} eventName
+     * @param {string} expr
+     */
+    protected processEventAttr(eventName: string, expr: string, meta?: string, child?: Child): void;
+    /**
+     * Process the bound property
+     * Register a watch on the bound expression
+     */
+    protected processBindAttr(propName: string, expr: string, child?: any): void;
+    /**
+     * Remove watch on the bound property
+     */
+    protected removePropertyBinding(propName: string): void;
+    /**
+     * invoke the event callback method
+     * @param {string} eventName
+     * @param extraLocals
+     */
+    invokeEventCallback(eventName: string, extraLocals?: any): any;
+    /**
+     * Process the attribute
+     * If the attribute is an event expression, generate a functional representation of the expression
+     *      and keep in eventHandlers
+     * If the attribute is a bound expression, register a watch on the expression
+     */
+    protected processAttr(attrName: string, attrValue: string, child?: Child): void;
+    /**
+     * This is required as the native element attributes are case insensitive(camelcase) like customExpressions becomes customexpression
+     * and our logic to check like these changes will fail. Before IVY changes, angular maintains a separate object with these attributes
+     * as it is like in the camelcase. With IVY all those are gone. So need to maintain a separate list with the camelcasing of attributes
+     * @private
+     * _tNode.attrs attributes are stored in array(even index: key, odd index: value)
+     */
+    protected getAttributes(): string[];
+    /**
+     * Process the attributes
+     */
+    private processAttrs;
+    /**
+     * Update the initState with the default property values and the values provided in the markup
+     * Process the attributes
+     * Register the widget
+     */
+    protected initWidget(): void;
+    /**
+     * Update the default properties and the properties provided in the markup in component
+     * Invoking this method will result in invocation of propertyChange handlers on the component for the first time
+     */
+    protected setInitProps(): void;
+    /**
+     * Returns true, if a listener registered for the given event on this widget markup.
+     * @param eventName
+     * @returns {boolean}
+     */
+    protected hasEventCallback(eventName: any): boolean;
+    /**
+     * Sets the focus on the widget
+     */
+    protected focus(): void;
+    protected execute(operation: any, options: any): any;
+    mute(): void;
+    unmute(): void;
+    private customInjectorMap;
+    /**
+     * After the Angular 17 upgrade, Angular is no longer sending ngTemplateContext to components in ng-template.
+     * Wavemaker widgets inside ng-template require context to evaluate bind expressions.
+     * So we're creating an injectionToken that returns the context as a value.
+     * We are passing the injectionToken to the ngTemplateOutletInjector.
+     * This injects the context into each widget in the ng-template.
+     * In the widget component constructor we are getting the injectionToken using dependency injection.
+     * If injectionToken is present, we extend the component context with the value of injectionToken.
+     * @param contextKey
+     * @param context
+     * @returns injector
+     */
+    createCustomInjector(contextKey: string, context: any): any;
+    /**
+     * After the host page is attached from cache, this function is called.
+     */
+    ngOnAttach(): void;
+    /**
+     * Before the host page is detached from dom and stored in cache,  this function is called.
+     */
+    ngOnDetach(): void;
+    /**
+     * nativeElement will be available by this time
+     * if the delayInit is false, properties meta will be available by this time
+     * Invoke the setInitProps if the delayInit is false
+     */
+    ngOnInit(): void;
+    /**
+     * Register the events
+     */
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent, [null, null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseComponent>;
+}
+export {};

package/components/base/widgets/common/base/custom-widget-container.directive.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef, Injector, OnDestroy, ViewContainerRef } from '@angular/core';
+import { App, CustomWidgetRefProvider } from '@wm/core';
+import * as i0 from "@angular/core";
+export declare class CustomWidgetContainerDirective implements OnDestroy {
+    componentInstance: any;
+    vcRef: ViewContainerRef;
+    elRef: ElementRef;
+    inj: Injector;
+    private app;
+    private customWidgetRefProvider;
+    constructor(componentInstance: any, vcRef: ViewContainerRef, elRef: ElementRef, inj: Injector, app: App, widgetname: string, customWidgetRefProvider: CustomWidgetRefProvider);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomWidgetContainerDirective, [{ self: true; }, null, null, null, null, { attribute: "widgetname"; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomWidgetContainerDirective, "[customWidgetContainer][widgetname]", never, {}, {}, never, never, true, never>;
+}

package/components/base/widgets/common/base/dataset-aware-nav.component.d.ts

@@ -0,0 +1,77 @@
+import { Injector, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { StylableComponent } from './stylable.component';
+import * as i0 from "@angular/core";
+export declare abstract class DatasetAwareNavComponent extends StylableComponent implements OnDestroy {
+    nodes: Array<NavNode>;
+    dataset: any;
+    itemicon: string;
+    itemlabel: string;
+    itemhint: string;
+    itemlink: string;
+    itemtarget: string;
+    itembadge: string;
+    itemchildren: string;
+    itemaction: string;
+    itemclass: string;
+    itemid: string;
+    isactive: string;
+    userrole: string;
+    orderby: string;
+    datafield: string;
+    displayfield: string;
+    private _itemFieldMap;
+    private binditemlabel;
+    private binditemhint;
+    private binditemicon;
+    private binditemaction;
+    private binditembadge;
+    private binditemchildren;
+    private binditemlink;
+    private binditemtarget;
+    private binduserrole;
+    private bindisactive;
+    private securityService;
+    protected binditemid: string | null;
+    protected nodes$: Subject<unknown>;
+    constructor(inj: Injector, WIDGET_CONFIG: any, explicitContext: any);
+    /**
+     * constructs individual node for the widget model.
+     * @param fields
+     * @param node
+     */
+    private getNode;
+    resetItemFieldMap(): void;
+    getItemFieldsMap(): any;
+    /**
+     * returns array for the value passed as nv.
+     * nv: 'a,b' => [{label:a, value:a}, {label:b, value:b}]
+     * nv: [1,2] => [{label:1, value:1}, {label:2, value:2}]
+     * nv: [{obj}, {obj}] => [{obj}, {obj}]
+     * @param nv
+     */
+    private prepareNodeDataSet;
+    /**
+     * constructs dataset form the nav elements.
+     */
+    private getNodes;
+    protected resetNodes(): void;
+    private _resetNodes;
+    onPropertyChange(key: any, nv: any, ov: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatasetAwareNavComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatasetAwareNavComponent>;
+}
+export interface NavNode {
+    label: string;
+    action?: any;
+    badge?: string;
+    children?: Array<NavNode>;
+    class?: string;
+    disabled?: boolean;
+    icon?: string;
+    id?: string;
+    link?: string;
+    role?: string;
+    value?: any;
+}

package/components/base/widgets/common/base/partial-container.directive.d.ts

@@ -0,0 +1,22 @@
+import { ComponentFactoryResolver, ElementRef, Injector, OnDestroy, ViewContainerRef } from '@angular/core';
+import { App, PartialRefProvider } from '@wm/core';
+import * as i0 from "@angular/core";
+export declare class PartialContainerDirective implements OnDestroy {
+    componentInstance: any;
+    vcRef: ViewContainerRef;
+    elRef: ElementRef;
+    inj: Injector;
+    private app;
+    private resolver;
+    private partialRefProvider;
+    private contentInitialized;
+    private $target;
+    get name(): any;
+    _renderPartial(nv: any): Promise<void>;
+    renderPartial: import("lodash").DebouncedFunc<(nv: any) => Promise<void>>;
+    onLoadSuccess(): void;
+    constructor(componentInstance: any, vcRef: ViewContainerRef, elRef: ElementRef, inj: Injector, app: App, _content: string, resolver: ComponentFactoryResolver, partialRefProvider: PartialRefProvider);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PartialContainerDirective, [{ self: true; }, null, null, null, null, { attribute: "content"; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PartialContainerDirective, "[partialContainer]", never, {}, {}, never, never, true, never>;
+}

package/components/base/widgets/common/base/stylable.component.d.ts

@@ -0,0 +1,54 @@
+import { BaseComponent } from './base.component';
+import * as i0 from "@angular/core";
+export declare abstract class StylableComponent extends BaseComponent {
+    backgroundattachment: string;
+    backgroundcolor: string;
+    backgroundgradient: string;
+    backgroundimage: string;
+    backgroundposition: string;
+    backgroundrepeat: string;
+    backgroundsize: string;
+    bordercolor: string;
+    borderradius: string;
+    borderstyle: string;
+    borderwidth: string;
+    borderbottomwidth: string;
+    borderleftwidth: string;
+    borderrightwidth: string;
+    bordertopwidth: string;
+    color: string;
+    cursor: string;
+    display: string;
+    fontsize: string;
+    fontfamily: string;
+    fontstyle: string;
+    fontunit: string;
+    fontvariant: string;
+    fontweight: string;
+    height: string;
+    horizontalalign: string;
+    lineheight: string;
+    margin: string;
+    marginbottom: string;
+    marginleft: string;
+    marginright: string;
+    margintop: string;
+    opacity: string;
+    overflow: string;
+    padding: string;
+    paddingbottom: string;
+    paddingleft: string;
+    paddingright: string;
+    paddingtop: string;
+    picturesource: string;
+    textalign: string;
+    textdecoration: string;
+    verticalalign: string;
+    visibility: string;
+    whitespace: string;
+    width: string;
+    wordbreak: string;
+    zindex: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StylableComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StylableComponent>;
+}

package/components/base/widgets/common/base/text-content.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TextContentDirective {
+    private elRef;
+    set textContent(nv: any);
+    constructor(elRef: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextContentDirective, "[textContent]", never, { "textContent": { "alias": "textContent"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/base/widgets/common/container/container.directive.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@angular/core';
+import { App } from '@wm/core';
+import { BaseContainerComponent } from "../base/base-container.component";
+import * as i0 from "@angular/core";
+export declare class ContainerDirective extends BaseContainerComponent {
+    app?: App;
+    static initializeProps: void;
+    isPrism: boolean;
+    constructor(inj: Injector, explicitContext?: any, app?: App);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerDirective, [null, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ContainerDirective, "[wmContainer]", never, {}, {}, never, never, true, never>;
+}

package/components/base/widgets/common/container/container.props.d.ts

@@ -0,0 +1 @@
+export declare const registerProps: () => void;