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

package/components/basic/search/data-provider/data-provider.d.ts

@@ -0,0 +1,42 @@
+import { LocalDataProvider } from './local-data-provider';
+import { RemoteDataProvider } from './remote-data-provider';
+export interface IDataProviderConfig {
+    dataoptions?: any;
+    viewParent?: any;
+    dataset: any;
+    datafield: string;
+    binddataset?: string;
+    datasource?: any;
+    hasData: boolean;
+    query: Array<string> | string;
+    isLocalFilter: boolean;
+    searchKey?: string;
+    matchMode?: string;
+    casesensitive?: boolean;
+    isformfield?: boolean;
+    orderby?: string;
+    limit?: number;
+    pagesize?: number;
+    page: number;
+    noMoredata?: boolean;
+    onBeforeservicecall?: Function;
+}
+export interface IDataProvider {
+    hasMoreData?: boolean;
+    isLastPage?: boolean;
+    hasNoMoreData?: boolean;
+    isPaginatedData?: boolean;
+    page?: number;
+    updateDataset?: boolean;
+    filter(config: IDataProviderConfig): Promise<any>;
+}
+export declare class DataProvider implements IDataProvider {
+    hasMoreData: boolean;
+    isLastPage: boolean;
+    page: number;
+    isPaginatedData: boolean;
+    updateDataset: boolean;
+    static remoteDataProvider: RemoteDataProvider;
+    static localDataProvider: LocalDataProvider;
+    filter(config: IDataProviderConfig): Promise<any>;
+}

package/components/basic/search/data-provider/local-data-provider.d.ts

@@ -0,0 +1,5 @@
+import { IDataProvider, IDataProviderConfig } from './data-provider';
+export declare class LocalDataProvider implements IDataProvider {
+    private applyFilter;
+    filter(config: IDataProviderConfig): Promise<any>;
+}

package/components/basic/search/data-provider/remote-data-provider.d.ts

@@ -0,0 +1,10 @@
+import { IDataProvider, IDataProviderConfig } from './data-provider';
+export declare class RemoteDataProvider implements IDataProvider {
+    filter(config: IDataProviderConfig): Promise<any>;
+    private filterData;
+    protected isLast(page: number, dataSize: number, maxResults: number, currentResults?: number): boolean;
+    protected getTransformedData(variable: any, data: any): any;
+    protected onFilterFailure(): any[];
+    private isLastPageForDistinctApi;
+    protected onFilterSuccess(config: IDataProviderConfig, response: any): Promise<any>;
+}

package/components/basic/search/esm2022/data-provider/data-provider.mjs

@@ -0,0 +1,34 @@
+import { DataSource } from '@wm/core';
+import { LocalDataProvider } from './local-data-provider';
+import { RemoteDataProvider } from './remote-data-provider';
+export class DataProvider {
+    static { this.remoteDataProvider = new RemoteDataProvider(); }
+    static { this.localDataProvider = new LocalDataProvider(); }
+    filter(config) {
+        let promise;
+        /**
+         * Make call to remoteDataProvider when searchkey is available and data is not from local / model variable.
+         * Otherwise use localDataProvider
+         * If datasource is a serviceVariable with no input params, then perform local search.
+         * when there is no dataset on the datasource when first time make a remote call to set the dataset for service variable.
+         */
+        const hasNoVariableDataset = config.datasource && config.datasource.execute(DataSource.Operation.IS_UPDATE_REQUIRED, config.hasData);
+        if (!config.isLocalFilter && (config.dataoptions || ((config.datasource && config.datasource.execute(DataSource.Operation.IS_API_AWARE))
+            && config.searchKey
+            && hasNoVariableDataset))) {
+            promise = DataProvider.remoteDataProvider.filter(config);
+        }
+        else {
+            promise = DataProvider.localDataProvider.filter(config);
+        }
+        return promise.then(response => {
+            this.updateDataset = config.datasource && !config.datasource.execute(DataSource.Operation.SUPPORTS_CRUD) && hasNoVariableDataset;
+            this.hasMoreData = response.hasMoreData;
+            this.isLastPage = response.isLastPage;
+            this.page = response.page;
+            this.isPaginatedData = response.isPaginatedData;
+            return response;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/components/basic/search/esm2022/data-provider/local-data-provider.mjs

@@ -0,0 +1,77 @@
+import { endsWith, filter, get, includes, isArray, isEqual, isNumber, isObject, split, startsWith, toLower, toString, values } from "lodash-es";
+export class LocalDataProvider {
+    applyFilter(entry, queryText, filtername) {
+        entry = isNumber(entry) ? entry.toString() : entry;
+        if (includes(filtername, 'start')) {
+            return startsWith(entry, queryText);
+        }
+        else if (includes(filtername, 'end')) {
+            return endsWith(entry, queryText);
+        }
+        else if (includes(filtername, 'exact')) {
+            return isEqual(entry, queryText);
+        }
+        return includes(entry, queryText);
+    }
+    // LocalData filtering is done based on the searchkey.
+    filter(config) {
+        const entries = config.dataset;
+        let casesensitive = config.casesensitive;
+        const matchMode = config.matchMode;
+        // for supporting existing projects
+        if (matchMode && !includes(matchMode, 'ignorecase')) {
+            casesensitive = true;
+        }
+        let queryText = config.query, filteredData;
+        return new Promise((resolve, reject) => {
+            /**
+             * If searchKey is defined, then check for match string against each item in the dataset with item's field name as the searchKey
+             * return the filtered data containing the matching string.
+             */
+            if (config.searchKey) {
+                const keys = split(config.searchKey, ',');
+                filteredData = filter(config.dataset, (item) => {
+                    return keys.some(key => {
+                        let a = get(item, key), b = queryText;
+                        if (!casesensitive) {
+                            a = toLower(toString(a));
+                            b = toLower(toString(b));
+                        }
+                        return this.applyFilter(a, b, matchMode);
+                    });
+                });
+            }
+            else {
+                // local search on data with array of objects.
+                // Iterate over each item and return the filtered data containing the matching string.
+                if (isArray(entries) && isObject(entries[0])) {
+                    filteredData = filter(entries, entry => {
+                        let a = values(entry).join(' ');
+                        if (!casesensitive) {
+                            a = toLower(a);
+                            // @ts-ignore
+                            queryText = toLower(queryText);
+                        }
+                        return this.applyFilter(a, queryText);
+                    });
+                }
+                else {
+                    filteredData = filter(entries, entry => {
+                        if (!casesensitive) {
+                            entry = toLower(entry);
+                            // @ts-ignore
+                            queryText = toLower(queryText);
+                        }
+                        return this.applyFilter(entry, queryText, matchMode);
+                    });
+                }
+            }
+            resolve({
+                data: filteredData,
+                hasMoreData: false,
+                isLastPage: true
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-data-provider.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/basic/search/src/data-provider/local-data-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { IDataProvider, IDataProviderConfig } from './data-provider';\nimport {\n    endsWith,\n    filter,\n    get,\n    includes,\n    isArray,\n    isEqual,\n    isNumber,\n    isObject,\n    split,\n    startsWith,\n    toLower,\n    toString,\n    values\n} from \"lodash-es\";\n\nexport class LocalDataProvider implements IDataProvider {\n    private applyFilter(entry, queryText, filtername?) {\n        entry = isNumber(entry) ? entry.toString() : entry;\n        if (includes(filtername, 'start')) {\n            return startsWith(entry, queryText);\n        } else if (includes(filtername, 'end')) {\n            return endsWith(entry, queryText);\n        } else if (includes(filtername, 'exact')) {\n            return isEqual(entry, queryText);\n        }\n        return includes(entry, queryText);\n    }\n\n    // LocalData filtering is done based on the searchkey.\n    public filter(config: IDataProviderConfig): Promise<any> {\n        const entries = config.dataset;\n        let casesensitive = config.casesensitive;\n        const matchMode = config.matchMode;\n        // for supporting existing projects\n        if (matchMode && !includes(matchMode, 'ignorecase')) {\n            casesensitive = true;\n        }\n        let queryText = config.query,\n        filteredData;\n\n        return new Promise((resolve, reject) => {\n            /**\n             * If searchKey is defined, then check for match string against each item in the dataset with item's field name as the searchKey\n             * return the filtered data containing the matching string.\n             */\n            if (config.searchKey) {\n                const keys = split(config.searchKey, ',');\n\n                filteredData = filter(config.dataset, (item: any) => {\n                    return keys.some(key => {\n                        let a = get(item, key),\n                            b = queryText;\n                        if (!casesensitive) {\n                            a = toLower(toString(a));\n                            b = toLower(toString(b));\n                        }\n                        return this.applyFilter(a, b, matchMode);\n                    });\n                });\n            } else {\n                // local search on data with array of objects.\n                // Iterate over each item and return the filtered data containing the matching string.\n                if (isArray(entries) && isObject(entries[0])) {\n                    filteredData = filter(entries, entry => {\n                        let a = values(entry).join(' ');\n                        if (!casesensitive) {\n                            a = toLower(a);\n                            // @ts-ignore\n                            queryText = toLower(queryText);\n                        }\n                        return this.applyFilter(a, queryText);\n                    });\n                } else {\n                    filteredData = filter(entries, entry => {\n                        if (!casesensitive) {\n                            entry = toLower(entry);\n                            // @ts-ignore\n                            queryText = toLower(queryText);\n                        }\n                        return this.applyFilter(entry, queryText, matchMode);\n                    });\n                }\n            }\n            resolve({\n                data: filteredData,\n                hasMoreData: false,\n                isLastPage: true\n            });\n        });\n    }\n}\n"]}

package/components/basic/search/esm2022/data-provider/remote-data-provider.mjs

@@ -0,0 +1,124 @@
+import { AppConstants, DataSource, findValueOf, getClonedObject } from '@wm/core';
+import { interpolateBindExpressions } from '@wm/components/base';
+import { assign, get, indexOf, isArray, isEmpty, isObject, set, slice, split } from "lodash-es";
+export class RemoteDataProvider {
+    filter(config) {
+        return this.filterData(config).then(response => this.onFilterSuccess(config, response), () => this.onFilterFailure());
+    }
+    filterData(config) {
+        if (config.dataoptions) {
+            const dataoptions = config.dataoptions;
+            const requestParams = config.datasource.execute(DataSource.Operation.GET_REQUEST_PARAMS, config);
+            // If options are specified, make specifics calls to fetch the results
+            // Fetch the related field data
+            if (dataoptions.relatedField) {
+                return new Promise((resolve, reject) => {
+                    interpolateBindExpressions(config.viewParent, dataoptions.filterExpr, (filterexpressions) => {
+                        requestParams.filterExpr = dataoptions.filterExpr = filterexpressions;
+                        dataoptions.filterExpr = filterexpressions;
+                        config.datasource.execute(DataSource.Operation.GET_RELATED_TABLE_DATA, assign({ relatedField: dataoptions.relatedField }, requestParams)).then(resolve, reject);
+                    });
+                });
+            }
+            // Fetch the distinct data
+            if (dataoptions.distinctField) {
+                return config.datasource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {
+                    pagesize: config.limit || config.pagesize,
+                    page: config.page,
+                    fields: dataoptions.distinctField,
+                    entityName: dataoptions.tableName,
+                    filterFields: assign(dataoptions.filterFields, requestParams.filterFields),
+                    filterExpr: getClonedObject(dataoptions.filterExpr || {})
+                });
+            }
+        }
+        // search records using the searchkey
+        return config.datasource.execute(DataSource.Operation.SEARCH_RECORDS, config);
+    }
+    // Check if the page retrieved currently is the last page. If last page, don't send any more request
+    isLast(page, dataSize, maxResults, currentResults) {
+        // if last page info is not returned by backend and current results is less than max results, this is the last page
+        if (dataSize === AppConstants.INT_MAX_VALUE) {
+            return currentResults !== 0 && currentResults < maxResults;
+        }
+        const pageCount = ((dataSize > maxResults) ? (Math.ceil(dataSize / maxResults)) : (dataSize < 0 ? 0 : 1));
+        return page === pageCount;
+    }
+    // this function transform the response data in case it is not an array
+    getTransformedData(variable, data) {
+        const operationResult = variable.operation + 'Result'; // when output is only string it is available as oprationNameResult
+        const tempResponse = data[operationResult];
+        // in case data received is value as string then add that string value to object and convert object into array
+        if (tempResponse) {
+            const tempObj = {};
+            set(tempObj, operationResult, tempResponse);
+            data = [tempObj]; // convert data into an array having tempObj
+        }
+        else {
+            // in case data received is already an object then convert it into an array
+            data = [data];
+        }
+        return data;
+    }
+    onFilterFailure() {
+        return [];
+    }
+    isLastPageForDistinctApi(data, page, totalElements, _isLastPage) {
+        return page > 1 && !_isLastPage && isEmpty(data) && totalElements === AppConstants.INT_MAX_VALUE;
+    }
+    // this function processes the response depending on pageOptions, isPageable and prepares the formattedDataset.
+    onFilterSuccess(config, response) {
+        let data = response.data;
+        let formattedData;
+        let _isLastPage;
+        let page;
+        let isPaginatedData;
+        const expressionArray = split(config.binddataset, '.');
+        const dataExpression = slice(expressionArray, indexOf(expressionArray, 'dataSet') + 1).join('.');
+        const $I = '[$i]';
+        return new Promise((resolve, reject) => {
+            const pageOptions = response.pagination;
+            if (config.datasource.execute(DataSource.Operation.IS_PAGEABLE)) {
+                page = pageOptions.number + 1;
+                _isLastPage = this.isLast(page, (config.limit > 0 && config.limit) || pageOptions.totalElements, pageOptions.size, pageOptions.numberOfElements);
+                isPaginatedData = true;
+                if (this.isLastPageForDistinctApi(data, page, pageOptions.totalElements, _isLastPage)) {
+                    _isLastPage = true;
+                    resolve({
+                        data: [],
+                        isLastPage: _isLastPage,
+                        hasMoreData: page > 1,
+                        isPaginatedData,
+                        page
+                    });
+                    return;
+                }
+            }
+            // if data expression exists, extract the data from the expression path
+            if (dataExpression) {
+                if (isArray(data)) {
+                    const index = dataExpression.lastIndexOf($I);
+                    if (index > -1) {
+                        const restExpr = dataExpression.substr(index + 5);
+                        formattedData = data.map(datum => findValueOf(datum, restExpr));
+                    }
+                }
+                else if (isObject(data)) {
+                    formattedData = get(data, dataExpression);
+                }
+                data = formattedData || data;
+            }
+            if (!isArray(data)) {
+                data = this.getTransformedData(config.datasource, data);
+            }
+            // in case of no data received, resolve the promise with empty array
+            if (!data.length) {
+                resolve({ data: [], isLastPage: _isLastPage, hasMoreData: page > 1, isPaginatedData, page });
+            }
+            else {
+                resolve({ data: data, isLastPage: _isLastPage, hasMoreData: page > 1, isPaginatedData, page });
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-data-provider.js","sourceRoot":"","sources":["../../../../../../projects/components/widgets/basic/search/src/data-provider/remote-data-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { AppConstants, DataSource, findValueOf, getClonedObject } from '@wm/core';\n\nimport { convertDataToObject, interpolateBindExpressions } from '@wm/components/base';\nimport { IDataProvider, IDataProviderConfig } from './data-provider';\nimport {assign, get, indexOf, isArray, isEmpty, isObject, set, slice, split} from \"lodash-es\";\n\nexport class RemoteDataProvider implements IDataProvider {\n    public filter(config: IDataProviderConfig): Promise<any> {\n        return this.filterData(config).then(response => this.onFilterSuccess(config, response), () => this.onFilterFailure());\n    }\n\n    private filterData(config) {\n        if (config.dataoptions) {\n            const dataoptions = config.dataoptions;\n\n            const requestParams = config.datasource.execute(DataSource.Operation.GET_REQUEST_PARAMS, config);\n\n            // If options are specified, make specifics calls to fetch the results\n            // Fetch the related field data\n            if (dataoptions.relatedField) {\n                return new Promise((resolve, reject) => {\n                    interpolateBindExpressions(config.viewParent, dataoptions.filterExpr, (filterexpressions) => {\n                        requestParams.filterExpr = dataoptions.filterExpr = filterexpressions;\n                        dataoptions.filterExpr = filterexpressions;\n\n                        config.datasource.execute(\n                            DataSource.Operation.GET_RELATED_TABLE_DATA, assign({relatedField: dataoptions.relatedField}, requestParams)\n                        ).then(resolve, reject);\n                    });\n                });\n            }\n            // Fetch the distinct data\n            if (dataoptions.distinctField) {\n                return config.datasource.execute(\n                    DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS,\n                    {\n                        pagesize: config.limit || config.pagesize,\n                        page: config.page,\n                        fields: dataoptions.distinctField,\n                        entityName: dataoptions.tableName,\n                        filterFields: assign(dataoptions.filterFields, requestParams.filterFields),\n                        filterExpr: getClonedObject(dataoptions.filterExpr || {})\n\n                    }\n                );\n            }\n        }\n\n        // search records using the searchkey\n        return config.datasource.execute(\n            DataSource.Operation.SEARCH_RECORDS, config\n        );\n    }\n\n\n    // Check if the page retrieved currently is the last page. If last page, don't send any more request\n    protected isLast(page: number, dataSize: number, maxResults: number, currentResults?: number): boolean {\n        // if last page info is not returned by backend and current results is less than max results, this is the last page\n        if (dataSize === AppConstants.INT_MAX_VALUE) {\n            return currentResults !== 0 && currentResults < maxResults;\n        }\n        const pageCount = ((dataSize > maxResults) ? (Math.ceil(dataSize / maxResults)) : (dataSize < 0 ? 0 : 1));\n        return page === pageCount;\n    }\n\n    // this function transform the response data in case it is not an array\n    protected getTransformedData(variable: any, data: any): any {\n        const operationResult = variable.operation + 'Result'; // when output is only string it is available as oprationNameResult\n        const tempResponse = data[operationResult];\n\n        // in case data received is value as string then add that string value to object and convert object into array\n        if (tempResponse) {\n            const tempObj = {};\n            set(tempObj, operationResult, tempResponse);\n            data = [tempObj]; // convert data into an array having tempObj\n        } else {\n            // in case data received is already an object then convert it into an array\n            data = [data];\n        }\n\n        return data;\n    }\n\n    protected onFilterFailure() {\n        return [];\n    }\n\n    private isLastPageForDistinctApi(data, page, totalElements, _isLastPage) {\n        return page > 1 && !_isLastPage && isEmpty(data) && totalElements === AppConstants.INT_MAX_VALUE;\n    }\n\n\n    // this function processes the response depending on pageOptions, isPageable and prepares the formattedDataset.\n    protected onFilterSuccess(config: IDataProviderConfig, response): Promise<any> {\n        let data: any = response.data;\n        let formattedData: any;\n        let _isLastPage: boolean;\n        let page: number;\n        let isPaginatedData: boolean;\n\n        const expressionArray = split(config.binddataset, '.');\n        const dataExpression = slice(expressionArray, indexOf(expressionArray, 'dataSet') + 1).join('.');\n        const $I = '[$i]';\n\n        return new Promise((resolve, reject) => {\n            const pageOptions = response.pagination;\n\n            if (config.datasource.execute(DataSource.Operation.IS_PAGEABLE)) {\n                page = pageOptions.number + 1;\n                _isLastPage = this.isLast(page, (config.limit > 0 && config.limit) || pageOptions.totalElements, pageOptions.size, pageOptions.numberOfElements);\n                isPaginatedData = true;\n\n                if (this.isLastPageForDistinctApi(data, page, pageOptions.totalElements, _isLastPage)) {\n                    _isLastPage = true;\n                    resolve({\n                        data: [],\n                        isLastPage: _isLastPage,\n                        hasMoreData: page > 1,\n                        isPaginatedData,\n                        page\n                    });\n                    return;\n                }\n            }\n            // if data expression exists, extract the data from the expression path\n            if (dataExpression) {\n                if (isArray(data)) {\n                    const index = dataExpression.lastIndexOf($I);\n                    if(index > -1){\n                        const restExpr = dataExpression.substr(index + 5);\n                        formattedData = data.map(datum => findValueOf(datum, restExpr));\n                    }\n                } else if (isObject(data)) {\n                    formattedData = get(data, dataExpression);\n                }\n                data = formattedData || data;\n            }\n            if (!isArray(data)) {\n                data = this.getTransformedData(config.datasource, data);\n            }\n            // in case of no data received, resolve the promise with empty array\n            if (!data.length) {\n                resolve({data: [], isLastPage: _isLastPage, hasMoreData: page > 1, isPaginatedData, page});\n            } else {\n                resolve({data: data, isLastPage: _isLastPage, hasMoreData: page > 1, isPaginatedData, page});\n            }\n        });\n    }\n}\n"]}

package/components/basic/search/esm2022/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3dpZGdldHMvYmFzaWMvc2VhcmNoL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/components/basic/search/esm2022/public_api.mjs

@@ -0,0 +1,3 @@
+export * from './search.component';
+export * from './scrollable.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvd2lkZ2V0cy9iYXNpYy9zZWFyY2gvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zZWFyY2guY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsYWJsZS5kaXJlY3RpdmUnO1xuIl19

package/components/basic/search/esm2022/scrollable.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive, ElementRef, inject, Injector } from '@angular/core';
+import { SearchComponent } from './search.component';
+import * as i0 from "@angular/core";
+export class ScrollableDirective {
+    constructor(inj) {
+        this.searchRef = inject(SearchComponent);
+        this.elementRef = inj.get(ElementRef);
+    }
+    ngAfterContentInit() {
+        // MEMORY LEAK FIX: Store bound function reference for proper removal
+        this.boundNotifyParent = this.notifyParent.bind(this);
+        // add the scroll event listener on the ul element.
+        this.elementRef.nativeElement.addEventListener('scroll', this.boundNotifyParent);
+        this.searchRef.dropdownEl = $(this.elementRef.nativeElement);
+        this.searchRef.onDropdownOpen();
+    }
+    ngAfterViewInit() {
+        if (!this.searchRef.isMobileAutoComplete()) {
+            // assigning width for the dropdown.
+            const typeAheadInput = this.searchRef.$element.find('input').first();
+            this.searchRef.dropdownEl.width(typeAheadInput.outerWidth());
+        }
+    }
+    notifyParent(evt) {
+        this.searchRef.onScroll(this.elementRef.nativeElement, evt);
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Remove scroll event listener using stored bound function reference
+        if (this.elementRef && this.elementRef.nativeElement && this.boundNotifyParent) {
+            this.elementRef.nativeElement.removeEventListener('scroll', this.boundNotifyParent);
+            this.boundNotifyParent = null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableDirective, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ScrollableDirective, isStandalone: true, selector: "[scrollableHandler]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[scrollableHandler]'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,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