ag-grid-angular
Version:
AG Grid Angular Component
88 lines • 14.5 kB
JavaScript
import { Injectable, NgZone } from '@angular/core';
import { VanillaFrameworkOverrides } from 'ag-grid-community';
import { AngularFrameworkEventListenerService } from './angularFrameworkEventListenerService';
import * as i0 from "@angular/core";
export class AngularFrameworkOverrides extends VanillaFrameworkOverrides {
constructor(_ngZone) {
super('angular');
this._ngZone = _ngZone;
this.batchFrameworkComps = true;
// Flag used to control Zone behaviour when running tests as many test features rely on Zone.
this.isRunningWithinTestZone = false;
// Make all events run outside Angular as they often trigger the setup of event listeners
// By having the event listeners outside Angular we can avoid triggering change detection
// This also means that if a user calls an AG Grid API method from within their component
// the internal side effects will not trigger change detection. Without this the events would
// run inside Angular and trigger change detection as the source of the event was within the angular zone.
this.wrapIncoming = (callback, source) => this.runOutside(callback, source);
/**
* Make sure that any code that is executed outside of AG Grid is running within the Angular zone.
* This means users can update templates and use binding without having to do anything extra.
*/
this.wrapOutgoing = (callback) => this.runInsideAngular(callback);
this.isRunningWithinTestZone =
window?.AG_GRID_UNDER_TEST ?? !!window?.Zone?.AsyncTestZoneSpec;
if (!this._ngZone) {
this.runOutside = (callback) => callback();
}
else if (this.isRunningWithinTestZone) {
this.runOutside = (callback, source) => {
if (source === 'resize-observer' || source === 'popupPositioning') {
// ensure resize observer callbacks are run outside of Angular even under test due to Jest not supporting ResizeObserver
// which means it just loops continuously with a setTimeout with no way to flush the queue or have fixture.whenStable() resolve.
return this._ngZone.runOutsideAngular(callback);
}
// When under test run inside Angular so that tests can use fixture.whenStable() to wait for async operations to complete.
return callback();
};
}
else {
this.runOutside = (callback) => this._ngZone.runOutsideAngular(callback);
}
}
/**
* The shouldWrapOutgoing property is used to determine if events should be run outside of Angular or not.
* If an event handler is registered outside of Angular then we should not wrap the event handler
* with runInsideAngular() as the user may not have wanted this.
* This is also used to not wrap internal event listeners that are registered with RowNodes and Columns.
*/
get shouldWrapOutgoing() {
return this._ngZone && NgZone.isInAngularZone();
}
createLocalEventListenerWrapper(existingFrameworkEventListenerService, localEventService) {
if (this.shouldWrapOutgoing) {
return (existingFrameworkEventListenerService ??
(() => {
localEventService.setFrameworkOverrides(this);
return new AngularFrameworkEventListenerService(this);
})());
}
return undefined;
}
createGlobalEventListenerWrapper() {
return new AngularFrameworkEventListenerService(this);
}
isFrameworkComponent(comp) {
if (!comp) {
return false;
}
const prototype = comp.prototype;
return prototype && 'agInit' in prototype;
}
runInsideAngular(callback) {
if (!this._ngZone || NgZone.isInAngularZone()) {
return callback();
}
// Check for _ngZone existence as it is not present when Zoneless
return this._ngZone.run(callback);
}
runOutsideAngular(callback, source) {
return this.runOutside(callback, source);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularFrameworkOverrides, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularFrameworkOverrides }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularFrameworkOverrides, decorators: [{
type: Injectable
}], ctorParameters: () => [{ type: i0.NgZone }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angularFrameworkOverrides.js","sourceRoot":"","sources":["../../../../projects/ag-grid-angular/src/lib/angularFrameworkOverrides.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\n\nimport type {\n    FrameworkOverridesIncomingSource,\n    IFrameworkEventListenerService,\n    LocalEventService,\n} from 'ag-grid-community';\nimport { VanillaFrameworkOverrides } from 'ag-grid-community';\n\nimport { AngularFrameworkEventListenerService } from './angularFrameworkEventListenerService';\n\n@Injectable()\nexport class AngularFrameworkOverrides extends VanillaFrameworkOverrides {\n    public override readonly batchFrameworkComps: boolean = true;\n\n    // Flag used to control Zone behaviour when running tests as many test features rely on Zone.\n    private isRunningWithinTestZone: boolean = false;\n\n    private runOutside: <T>(callback: () => T, source?: FrameworkOverridesIncomingSource) => T;\n\n    constructor(private _ngZone: NgZone) {\n        super('angular');\n\n        this.isRunningWithinTestZone =\n            (window as any)?.AG_GRID_UNDER_TEST ?? !!(window as any)?.Zone?.AsyncTestZoneSpec;\n\n        if (!this._ngZone) {\n            this.runOutside = (callback) => callback();\n        } else if (this.isRunningWithinTestZone) {\n            this.runOutside = (callback, source) => {\n                if (source === 'resize-observer' || source === 'popupPositioning') {\n                    // ensure resize observer callbacks are run outside of Angular even under test due to Jest not supporting ResizeObserver\n                    // which means it just loops continuously with a setTimeout with no way to flush the queue or have fixture.whenStable() resolve.\n                    return this._ngZone.runOutsideAngular(callback);\n                }\n                // When under test run inside Angular so that tests can use fixture.whenStable() to wait for async operations to complete.\n                return callback();\n            };\n        } else {\n            this.runOutside = (callback) => this._ngZone.runOutsideAngular(callback);\n        }\n    }\n\n    // Make all events run outside Angular as they often trigger the setup of event listeners\n    // By having the event listeners outside Angular we can avoid triggering change detection\n    // This also means that if a user calls an AG Grid API method from within their component\n    // the internal side effects will not trigger change detection. Without this the events would\n    // run inside Angular and trigger change detection as the source of the event was within the angular zone.\n    override wrapIncoming: <T>(callback: () => T, source?: FrameworkOverridesIncomingSource) => T = (\n        callback,\n        source\n    ) => this.runOutside(callback, source);\n\n    /**\n     * The shouldWrapOutgoing property is used to determine if events should be run outside of Angular or not.\n     * If an event handler is registered outside of Angular then we should not wrap the event handler\n     * with runInsideAngular() as the user may not have wanted this.\n     * This is also used to not wrap internal event listeners that are registered with RowNodes and Columns.\n     */\n    public get shouldWrapOutgoing() {\n        return this._ngZone && NgZone.isInAngularZone();\n    }\n\n    /**\n     * Make sure that any code that is executed outside of AG Grid is running within the Angular zone.\n     * This means users can update templates and use binding without having to do anything extra.\n     */\n    override wrapOutgoing: <T>(callback: () => T) => T = (callback) => this.runInsideAngular(callback);\n\n    public createLocalEventListenerWrapper(\n        existingFrameworkEventListenerService: IFrameworkEventListenerService<any, any> | undefined,\n        localEventService: LocalEventService<any>\n    ): IFrameworkEventListenerService<any, any> | undefined {\n        if (this.shouldWrapOutgoing) {\n            return (\n                existingFrameworkEventListenerService ??\n                (() => {\n                    localEventService.setFrameworkOverrides(this);\n                    return new AngularFrameworkEventListenerService(this);\n                })()\n            );\n        }\n\n        return undefined;\n    }\n\n    public createGlobalEventListenerWrapper(): IFrameworkEventListenerService<any, any> {\n        return new AngularFrameworkEventListenerService(this);\n    }\n\n    override isFrameworkComponent(comp: any): boolean {\n        if (!comp) {\n            return false;\n        }\n        const prototype = comp.prototype;\n        return prototype && 'agInit' in prototype;\n    }\n\n    runInsideAngular<T>(callback: () => T): T {\n        if (!this._ngZone || NgZone.isInAngularZone()) {\n            return callback();\n        }\n\n        // Check for _ngZone existence as it is not present when Zoneless\n        return this._ngZone.run(callback);\n    }\n\n    runOutsideAngular<T>(callback: () => T, source?: FrameworkOverridesIncomingSource): T {\n        return this.runOutside(callback, source);\n    }\n}\n"]}