ag-grid-aurelia-plugin 31.3.4 → 31.3.6

package/lib/agGridAurelia.d.ts

@@ -0,0 +1,35 @@
+// ag-grid-aurelia-plugin v31.3.4
+import type { GridOptions } from "ag-grid-community";
+import { ColumnApi, GridApi } from "ag-grid-community";
+import { ComponentAttached, ComponentDetached, Container, TaskQueue, ViewResources } from "aurelia-framework";
+import { AureliaFrameworkFactory } from "./aureliaFrameworkFactory";
+import { AgGridColumn } from "./agGridColumn";
+import { AgDateTemplate, AgFullWidthRowTemplate } from './agTemplate';
+import { AureliaFrameworkComponentWrapper } from "./aureliaFrameworkComponentWrapper";
+export declare class AgGridAurelia implements ComponentAttached, ComponentDetached {
+    private taskQueue;
+    private auFrameworkFactory;
+    private container;
+    private viewResources;
+    private aureliaFrameworkComponentWrapper;
+    private _nativeElement;
+    private _initialised;
+    private _destroyed;
+    gridOptions: GridOptions;
+    context: any;
+    private gridParams;
+    api: GridApi;
+    columnApi: ColumnApi;
+    columns: AgGridColumn[];
+    fullWidthRowTemplate: AgFullWidthRowTemplate;
+    dateTemplate: AgDateTemplate;
+    constructor(element: Element, taskQueue: TaskQueue, auFrameworkFactory: AureliaFrameworkFactory, container: Container, viewResources: ViewResources, aureliaFrameworkComponentWrapper: AureliaFrameworkComponentWrapper);
+    attached(): void;
+    initGrid(): void;
+    /**
+     * Called by Aurelia whenever a bound property changes
+     */
+    propertyChanged(propertyName: string, newValue: any, oldValue: any): void;
+    detached(): void;
+    private globalEventListener;
+}

package/lib/agGridAurelia.js

@@ -0,0 +1,159 @@
+// ag-grid-aurelia-plugin v31.3.4
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ComponentUtil, Grid } from "ag-grid-community";
+import { bindable, child, children, Container, customElement, inlineView, TaskQueue, ViewResources } from "aurelia-framework";
+import { AureliaFrameworkFactory } from "./aureliaFrameworkFactory";
+import { generateBindables } from "./agUtils";
+import { AgDateTemplate, AgFullWidthRowTemplate } from './agTemplate';
+import { AureliaFrameworkComponentWrapper } from "./aureliaFrameworkComponentWrapper";
+let AgGridAurelia = class AgGridAurelia {
+    taskQueue;
+    auFrameworkFactory;
+    container;
+    viewResources;
+    aureliaFrameworkComponentWrapper;
+    // not intended for user to interact with. so putting _ in so if user gets reference
+    // to this object, they kind'a know it's not part of the agreed interface
+    _nativeElement;
+    _initialised = false;
+    _destroyed = false;
+    gridOptions;
+    context;
+    gridParams;
+    // making these public, so they are accessible to people using the aurelia component references
+    api;
+    columnApi;
+    columns = [];
+    fullWidthRowTemplate;
+    dateTemplate;
+    constructor(element, taskQueue, auFrameworkFactory, container, viewResources, aureliaFrameworkComponentWrapper) {
+        this.taskQueue = taskQueue;
+        this.auFrameworkFactory = auFrameworkFactory;
+        this.container = container;
+        this.viewResources = viewResources;
+        this.aureliaFrameworkComponentWrapper = aureliaFrameworkComponentWrapper;
+        this._nativeElement = element;
+        // create all the events generically. this is done generically so that
+        // if the list of grid events change, we don't need to change this code.
+        ComponentUtil.EVENTS.forEach((eventName) => {
+            //create an empty event
+            this[eventName] = () => {
+            };
+        });
+    }
+    attached() {
+        // initialize the grid in the queue
+        // because of bug in @children
+        // https://github.com/aurelia/templating/issues/403
+        this.taskQueue.queueTask(this.initGrid.bind(this));
+    }
+    initGrid() {
+        this._initialised = false;
+        this._destroyed = false;
+        this.auFrameworkFactory.setContainer(this.container);
+        this.auFrameworkFactory.setViewResources(this.viewResources);
+        this.aureliaFrameworkComponentWrapper.setContainer(this.container);
+        this.aureliaFrameworkComponentWrapper.setViewResources(this.viewResources);
+        this.gridParams = {
+            globalEventListener: this.globalEventListener.bind(this),
+            frameworkFactory: this.auFrameworkFactory,
+            seedBeanInstances: {
+                frameworkComponentWrapper: this.aureliaFrameworkComponentWrapper
+            }
+        };
+        if (this.columns && this.columns.length > 0) {
+            this.gridOptions.columnDefs = this.columns
+                .map((column) => {
+                return column.toColDef();
+            });
+        }
+        if (this.fullWidthRowTemplate) {
+            this.gridOptions.fullWidthCellRenderer =
+                { template: this.fullWidthRowTemplate.template };
+        }
+        if (this.dateTemplate) {
+            this.gridOptions.dateComponentFramework =
+                { template: this.dateTemplate.template };
+        }
+        new Grid(this._nativeElement, this.gridOptions, this.gridParams);
+        this.api = this.gridOptions.api;
+        this.columnApi = this.gridOptions.columnApi;
+        this._initialised = true;
+    }
+    /**
+     * Called by Aurelia whenever a bound property changes
+     */
+    propertyChanged(propertyName, newValue, oldValue) {
+        // emulate an Angular2 SimpleChanges Object
+        let changes = {};
+        changes[propertyName] = { currentValue: newValue, previousValue: oldValue };
+        if (this._initialised) {
+            ComponentUtil.processOnChange(changes, this.api);
+        }
+    }
+    detached() {
+        if (this._initialised) {
+            // need to do this before the destroy, so we know not to emit any events
+            // while tearing down the grid.
+            this._destroyed = true;
+            this.api.destroy();
+        }
+    }
+    globalEventListener(eventType, event) {
+        // if we are tearing down, don't emit events
+        if (this._destroyed) {
+            return;
+        }
+        // generically look up the eventType
+        let emitter = this[eventType];
+        if (emitter) {
+            emitter(event);
+        }
+        else {
+            console.log('ag-Grid-aurelia: could not find EventEmitter: ' + eventType);
+        }
+    }
+};
+__decorate([
+    bindable(),
+    __metadata("design:type", Object)
+], AgGridAurelia.prototype, "gridOptions", void 0);
+__decorate([
+    bindable(),
+    __metadata("design:type", Object)
+], AgGridAurelia.prototype, "context", void 0);
+__decorate([
+    children('ag-grid-column'),
+    __metadata("design:type", Array)
+], AgGridAurelia.prototype, "columns", void 0);
+__decorate([
+    child('ag-full-width-row-template'),
+    __metadata("design:type", AgFullWidthRowTemplate)
+], AgGridAurelia.prototype, "fullWidthRowTemplate", void 0);
+__decorate([
+    child('ag-date-template'),
+    __metadata("design:type", AgDateTemplate)
+], AgGridAurelia.prototype, "dateTemplate", void 0);
+AgGridAurelia = __decorate([
+    customElement('ag-grid-aurelia'),
+    generateBindables(ComponentUtil.ALL_PROPERTIES.filter((property) => property !== 'gridOptions')),
+    generateBindables(ComponentUtil.EVENTS)
+    // <slot> is required for @children to work.  https://github.com/aurelia/templating/issues/451#issuecomment-254206622
+    ,
+    inlineView(`<template><slot></slot></template>`),
+    __metadata("design:paramtypes", [Element,
+        TaskQueue,
+        AureliaFrameworkFactory,
+        Container,
+        ViewResources,
+        AureliaFrameworkComponentWrapper])
+], AgGridAurelia);
+export { AgGridAurelia };

package/lib/agGridColumn.d.ts

@@ -0,0 +1,18 @@
+// ag-grid-aurelia-plugin v31.3.4
+import { ColDef } from "ag-grid-community";
+import { AgCellTemplate, AgEditorTemplate, AgFilterTemplate, AgHeaderGroupTemplate, AgHeaderTemplate, AgPinnedRowTemplate } from "./agTemplate";
+export declare class AgGridColumn {
+    private mappedColumnProperties;
+    childColumns: AgGridColumn[];
+    cellTemplate: AgCellTemplate;
+    editorTemplate: AgEditorTemplate;
+    filterTemplate: AgFilterTemplate;
+    headerTemplate: AgHeaderTemplate;
+    headerGroupTemplate: AgHeaderGroupTemplate;
+    pinnedRowTemplate: AgPinnedRowTemplate;
+    constructor();
+    hasChildColumns(): boolean;
+    toColDef(): ColDef;
+    private static getChildColDefs;
+    private createColDefFromGridColumn;
+}

package/lib/agGridColumn.js

@@ -0,0 +1,155 @@
+// ag-grid-aurelia-plugin v31.3.4
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AgGridColumn_1;
+import { autoinject, child, children, customElement, inlineView } from "aurelia-framework";
+import { AgCellTemplate, AgEditorTemplate, AgFilterTemplate, AgHeaderGroupTemplate, AgHeaderTemplate, AgPinnedRowTemplate } from "./agTemplate";
+import { generateBindables } from "./agUtils";
+let AgGridColumn = AgGridColumn_1 = class AgGridColumn {
+    mappedColumnProperties = {
+        "hideCol": "hide" // hide exists in aurelia-templating-resources and will conflict
+    };
+    childColumns = [];
+    cellTemplate;
+    editorTemplate;
+    filterTemplate;
+    headerTemplate;
+    headerGroupTemplate;
+    pinnedRowTemplate;
+    constructor() {
+    }
+    hasChildColumns() {
+        return this.childColumns && this.childColumns.length > 0;
+    }
+    toColDef() {
+        let colDef = this.createColDefFromGridColumn();
+        if (this.hasChildColumns()) {
+            colDef["children"] = AgGridColumn_1.getChildColDefs(this.childColumns);
+        }
+        const defaultAction = (templateName) => {
+            let self = this;
+            if (self[templateName]) {
+                const frameworkName = templates[templateName].frameworkName;
+                colDef[frameworkName] = { template: self[templateName].template };
+                delete colDef[templateName];
+            }
+        };
+        const editorAction = (templateName) => {
+            if (colDef.editable === undefined) {
+                colDef.editable = true;
+            }
+            defaultAction(templateName);
+        };
+        const templates = {
+            cellTemplate: {
+                frameworkName: 'cellRendererFramework'
+            },
+            editorTemplate: {
+                frameworkName: 'cellEditorFramework',
+                action: editorAction
+            },
+            filterTemplate: {
+                frameworkName: 'filterFramework'
+            },
+            headerTemplate: {
+                frameworkName: 'headerComponentFramework'
+            },
+            headerGroupTemplate: {
+                frameworkName: 'headerGroupComponentFramework'
+            },
+            pinnedRowTemplate: {
+                frameworkName: 'pinnedRowCellRendererFramework'
+            }
+        };
+        const addTemplate = (templateName) => {
+            const action = templates[templateName].action ? templates[templateName].action : defaultAction;
+            action(templateName);
+        };
+        Object.keys(templates)
+            .forEach(addTemplate);
+        return colDef;
+    }
+    static getChildColDefs(childColumns) {
+        return childColumns
+            .filter(column => !column.hasChildColumns())
+            .map((column) => {
+            return column.toColDef();
+        });
+    }
+    ;
+    createColDefFromGridColumn() {
+        let colDef = {};
+        for (let prop in this) {
+            // only map this property if it's been actually been set
+            if (this[prop] === undefined) {
+                continue;
+            }
+            let colDefProperty = this.mappedColumnProperties[prop] ? this.mappedColumnProperties[prop] : prop;
+            colDef[colDefProperty] = this[prop];
+        }
+        delete colDef.childColumns;
+        return colDef;
+    }
+    ;
+};
+__decorate([
+    children('ag-grid-column'),
+    __metadata("design:type", Array)
+], AgGridColumn.prototype, "childColumns", void 0);
+__decorate([
+    child('ag-cell-template'),
+    __metadata("design:type", AgCellTemplate)
+], AgGridColumn.prototype, "cellTemplate", void 0);
+__decorate([
+    child('ag-editor-template'),
+    __metadata("design:type", AgEditorTemplate)
+], AgGridColumn.prototype, "editorTemplate", void 0);
+__decorate([
+    child('ag-filter-template'),
+    __metadata("design:type", AgFilterTemplate)
+], AgGridColumn.prototype, "filterTemplate", void 0);
+__decorate([
+    child('ag-header-template'),
+    __metadata("design:type", AgHeaderTemplate)
+], AgGridColumn.prototype, "headerTemplate", void 0);
+__decorate([
+    child('ag-header-group-template'),
+    __metadata("design:type", AgHeaderGroupTemplate)
+], AgGridColumn.prototype, "headerGroupTemplate", void 0);
+__decorate([
+    child('ag-pinned-row-template'),
+    __metadata("design:type", AgPinnedRowTemplate)
+], AgGridColumn.prototype, "pinnedRowTemplate", void 0);
+AgGridColumn = AgGridColumn_1 = __decorate([
+    customElement('ag-grid-column'),
+    generateBindables(["colId", "sort", "sortedAt", "sortingOrder", "field", "headerValueGetter", "hideCol", "pinned",
+        "tooltipField", "headerTooltip", "valueGetter", "keyCreator", "floatingFilterComponentFramework", "rowDrag",
+        "width", "minWidth", "maxWidth", "cellClass", "cellStyle", "cellRenderer", "cellRendererFramework",
+        "cellRendererParams", "cellEditor", "cellEditorFramework", "cellEditorParams", "floatingCellRenderer",
+        "floatingCellRendererFramework", "floatingCellRendererParams", "cellFormatter", "floatingCellFormatter",
+        "getQuickFilterText", "aggFunc", "rowGroupIndex", "pivotIndex", "comparator", "checkboxSelection", "suppressMenu",
+        "suppressSorting", "suppressMovable", "suppressFilter", "unSortIcon", "suppressSizeToFit", "suppressResize",
+        "suppressAutoSize", "suppressToolPanel", "suppressKeyboardEvent", "enableRowGroup", "enablePivot", "enableValue",
+        "editable", "suppressNavigable", "newValueHandler", "volatile", "filter", "filterFramework", "filterParams",
+        "cellClassRules", "onCellValueChanged", "onCellClicked", "onCellDoubleClicked", "onCellContextMenu", "icons",
+        "enableCellChangeFlash", "headerName", "columnGroupShow", "headerClass", "toolPanelClass", "children", "groupId", "openByDefault",
+        "marryChildren", "headerCheckboxSelection", "headerCheckboxSelectionFilteredOnly", "type", "valueSetter",
+        "pinnedRowCellRenderer", "pinnedRowCellRendererFramework", "pinnedRowCellRendererParams", "valueFormatter",
+        "pinnedRowValueFormatter", "valueParser", "allowedAggFuncs", "rowGroup", "showRowGroup", "pivot", "equals", "pivotComparator",
+        "menuTabs", "colSpan", "suppressPaste", "template", "templateUrl", "pivotValueColumn", "pivotTotalColumnIds", "headerComponent",
+        "headerComponentFramework", "headerComponentParams", "floatingFilterComponent", "floatingFilterComponentParams",
+        "lockPinned"])
+    // <slot> is required for @children to work.  https://github.com/aurelia/templating/issues/451#issuecomment-254206622
+    ,
+    inlineView(`<template><slot></slot></template>`),
+    autoinject(),
+    __metadata("design:paramtypes", [])
+], AgGridColumn);
+export { AgGridColumn };

package/lib/agTemplate.d.ts

@@ -0,0 +1,34 @@
+// ag-grid-aurelia-plugin v31.3.4
+import { TargetInstruction } from "aurelia-framework";
+export declare class AgCellTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgEditorTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgFilterTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgHeaderTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgHeaderGroupTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgPinnedRowTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgDateTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}
+export declare class AgFullWidthRowTemplate {
+    template: string;
+    constructor(targetInstruction: TargetInstruction);
+}

package/lib/agTemplate.js

@@ -0,0 +1,142 @@
+// ag-grid-aurelia-plugin v31.3.4
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { autoinject, customElement, noView, processContent, TargetInstruction } from "aurelia-framework";
+/**
+ * Function will move the elements innerHtml to a template property
+ * and then remove html from the element so that Aurelia will not render
+ * the template elements
+ * @param compiler
+ * @param resources
+ * @param element
+ * @param instruction
+ */
+function parseElement(compiler, resources, element, instruction) {
+    let html = element.innerHTML;
+    if (html !== '') {
+        instruction.template = html;
+    }
+    element.innerHTML = '';
+}
+function getTemplate(targetInstruction) {
+    return `<template>` + targetInstruction.elementInstruction.template + `</template>`;
+}
+let AgCellTemplate = class AgCellTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgCellTemplate = __decorate([
+    customElement('ag-cell-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgCellTemplate);
+export { AgCellTemplate };
+let AgEditorTemplate = class AgEditorTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgEditorTemplate = __decorate([
+    customElement('ag-editor-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgEditorTemplate);
+export { AgEditorTemplate };
+let AgFilterTemplate = class AgFilterTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgFilterTemplate = __decorate([
+    customElement('ag-filter-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgFilterTemplate);
+export { AgFilterTemplate };
+let AgHeaderTemplate = class AgHeaderTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgHeaderTemplate = __decorate([
+    customElement('ag-header-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgHeaderTemplate);
+export { AgHeaderTemplate };
+let AgHeaderGroupTemplate = class AgHeaderGroupTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgHeaderGroupTemplate = __decorate([
+    customElement('ag-header-group-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgHeaderGroupTemplate);
+export { AgHeaderGroupTemplate };
+let AgPinnedRowTemplate = class AgPinnedRowTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgPinnedRowTemplate = __decorate([
+    customElement('ag-pinned-row-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgPinnedRowTemplate);
+export { AgPinnedRowTemplate };
+let AgDateTemplate = class AgDateTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgDateTemplate = __decorate([
+    customElement('ag-date-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgDateTemplate);
+export { AgDateTemplate };
+let AgFullWidthRowTemplate = class AgFullWidthRowTemplate {
+    template;
+    constructor(targetInstruction) {
+        this.template = getTemplate(targetInstruction);
+    }
+};
+AgFullWidthRowTemplate = __decorate([
+    customElement('ag-full-width-row-template'),
+    noView(),
+    autoinject(),
+    processContent(parseElement),
+    __metadata("design:paramtypes", [TargetInstruction])
+], AgFullWidthRowTemplate);
+export { AgFullWidthRowTemplate };

package/lib/agUtils.d.ts

@@ -0,0 +1,2 @@
+// ag-grid-aurelia-plugin v31.3.4
+export declare function generateBindables(names: string[], bindingModeToUse?: any): any;

package/lib/agUtils.js

@@ -0,0 +1,22 @@
+// ag-grid-aurelia-plugin v31.3.4
+import { BindableProperty, HtmlBehaviorResource, metadata } from "aurelia-framework";
+export function generateBindables(names, bindingModeToUse) {
+    return function (target, key, descriptor) {
+        // get or create the HtmlBehaviorResource
+        // on which we're going to create the BindableProperty's
+        let behaviorResource = metadata.getOrCreateOwn(metadata.resource, HtmlBehaviorResource, target);
+        let nameOrConfigOrTargets = names.map((name) => {
+            let nameOrConfigOrTarget = {
+                name: name
+            };
+            if (bindingModeToUse) {
+                nameOrConfigOrTarget["defaultBindingMode"] = bindingModeToUse;
+            }
+            return nameOrConfigOrTarget;
+        });
+        nameOrConfigOrTargets.forEach((nameOrConfigOrTarget) => {
+            let prop = new BindableProperty(nameOrConfigOrTarget);
+            prop.registerWith(target, behaviorResource, descriptor);
+        });
+    };
+}

package/lib/aureliaFrameworkComponentWrapper.d.ts

@@ -0,0 +1,13 @@
+// ag-grid-aurelia-plugin v31.3.4
+import { Container, TaskQueue, ViewCompiler, ViewResources } from "aurelia-framework";
+import { BaseComponentWrapper, FrameworkComponentWrapper, WrappableInterface } from 'ag-grid-community';
+export declare class AureliaFrameworkComponentWrapper extends BaseComponentWrapper<WrappableInterface> implements FrameworkComponentWrapper {
+    private taskQueue;
+    private _viewCompiler;
+    private _container;
+    private _viewResources;
+    constructor(taskQueue: TaskQueue, _viewCompiler: ViewCompiler);
+    createWrapper(template: any): WrappableInterface;
+    setContainer(container: Container): void;
+    setViewResources(viewResources: ViewResources): void;
+}

package/lib/aureliaFrameworkComponentWrapper.js

@@ -0,0 +1,112 @@
+// ag-grid-aurelia-plugin v31.3.4
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { autoinject, TaskQueue, transient, ViewCompiler } from "aurelia-framework";
+import { BaseComponentWrapper, Bean } from 'ag-grid-community';
+let AureliaFrameworkComponentWrapper = class AureliaFrameworkComponentWrapper extends BaseComponentWrapper {
+    taskQueue;
+    _viewCompiler;
+    _container;
+    _viewResources;
+    constructor(taskQueue, _viewCompiler) {
+        super();
+        this.taskQueue = taskQueue;
+        this._viewCompiler = _viewCompiler;
+    }
+    createWrapper(template) {
+        let that = this;
+        class DynamicComponent extends BaseGuiComponent {
+            constructor() {
+                super(that.taskQueue, that._viewCompiler);
+            }
+            init(params) {
+                super.init(params, template.template, that._viewResources, that._container);
+            }
+            hasMethod(name) {
+                return wrapper.getFrameworkComponentInstance() && wrapper.getFrameworkComponentInstance()[name] != null;
+            }
+            callMethod(name, args) {
+                const componentRef = this.getFrameworkComponentInstance();
+                return wrapper.getFrameworkComponentInstance()[name].apply(componentRef, args);
+            }
+            addMethod(name, callback) {
+                wrapper[name] = callback;
+            }
+        }
+        const wrapper = new DynamicComponent();
+        return wrapper;
+    }
+    setContainer(container) {
+        this._container = container;
+    }
+    setViewResources(viewResources) {
+        this._viewResources = viewResources;
+    }
+};
+AureliaFrameworkComponentWrapper = __decorate([
+    autoinject(),
+    transient(),
+    Bean("frameworkComponentWrapper"),
+    __metadata("design:paramtypes", [TaskQueue, ViewCompiler])
+], AureliaFrameworkComponentWrapper);
+export { AureliaFrameworkComponentWrapper };
+class BaseGuiComponent {
+    _taskQueue;
+    _viewCompiler;
+    _params;
+    _view;
+    constructor(taskQueue, viewCompiler) {
+        this._taskQueue = taskQueue;
+        this._viewCompiler = viewCompiler;
+    }
+    init(params, template, viewResources, container) {
+        this._params = params;
+        let bindingContext = { params: params };
+        let viewFactory = this._viewCompiler.compile(template, viewResources);
+        this._view = viewFactory.create(container);
+        let controllers = this._view.controllers;
+        //initialize each controller
+        if (controllers && controllers.length) {
+            controllers.forEach((c) => {
+                c.viewModel.params = params;
+            });
+            this._view.bind(bindingContext);
+            //ICellRenderer doesn't have a guiAttached method so
+            //we call attach on the queue;
+            this._taskQueue.queueMicroTask(() => this._view.attached());
+        }
+        else {
+            this._view.bind(bindingContext);
+        }
+    }
+    getGui() {
+        return this._view.fragment;
+    }
+    destroy() {
+        this._view.returnToCache();
+    }
+    refresh(params) {
+        return false;
+    }
+    getFrameworkComponentInstance() {
+        let controllers = this._view.controllers;
+        //only one controller is allowed in editor template
+        if (controllers &&
+            controllers.length == 1 &&
+            controllers[0].viewModel) {
+            let editorVm = controllers[0].viewModel;
+            //this is a 'hack' because we don't have params.bind="" in the template
+            //must reset params or it will be nothing
+            editorVm.params = this._params;
+            return editorVm;
+        }
+        return null;
+    }
+}

package/lib/aureliaFrameworkFactory.d.ts

@@ -0,0 +1,21 @@
+// ag-grid-aurelia-plugin v31.3.4
+import { Container, ViewResources } from "aurelia-framework";
+import { IFrameworkOverrides, AgPromise, FrameworkOverridesIncomingSource } from "ag-grid-community";
+export declare class AureliaFrameworkFactory implements IFrameworkOverrides {
+    setInterval(action: any, interval?: any): AgPromise<number>;
+    addEventListener(element: HTMLElement, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    wrapIncoming: <T>(callback: () => T, source?: FrameworkOverridesIncomingSource) => T;
+    wrapOutgoing: <T>(callback: () => T) => T;
+    shouldWrapOutgoing?: boolean;
+    frameworkComponent(name: string, components?: any): void;
+    isFrameworkComponent(comp: any): boolean;
+    renderingEngine: "vanilla" | "react";
+    getDocLink(path?: string): string;
+    private _container;
+    private _viewResources;
+    private _baseFrameworkFactory;
+    setContainer(container: Container): void;
+    setViewResources(viewResources: ViewResources): void;
+    setTimeout(action: any, timeout?: any): void;
+    addEventListenerOutsideAngular(element: HTMLElement, type: string, listener: EventListener | EventListenerObject, useCapture?: boolean): void;
+}

package/lib/aureliaFrameworkFactory.js

@@ -0,0 +1,50 @@
+// ag-grid-aurelia-plugin v31.3.4
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { autoinject, transient } from "aurelia-framework";
+import { VanillaFrameworkOverrides } from "ag-grid-community";
+let AureliaFrameworkFactory = class AureliaFrameworkFactory {
+    setInterval(action, interval) {
+        throw new Error("Method not implemented.");
+    }
+    addEventListener(element, type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    wrapIncoming;
+    wrapOutgoing;
+    shouldWrapOutgoing;
+    frameworkComponent(name, components) {
+        throw new Error("Method not implemented.");
+    }
+    isFrameworkComponent(comp) {
+        throw new Error("Method not implemented.");
+    }
+    renderingEngine;
+    getDocLink(path) {
+        throw new Error("Method not implemented.");
+    }
+    _container;
+    _viewResources;
+    _baseFrameworkFactory = new VanillaFrameworkOverrides(); // todo - inject this
+    setContainer(container) {
+        this._container = container;
+    }
+    setViewResources(viewResources) {
+        this._viewResources = viewResources;
+    }
+    setTimeout(action, timeout) {
+        window.setTimeout(action, timeout);
+    }
+    addEventListenerOutsideAngular(element, type, listener, useCapture) {
+        element.addEventListener(type, listener, useCapture);
+    }
+};
+AureliaFrameworkFactory = __decorate([
+    autoinject(),
+    transient()
+], AureliaFrameworkFactory);
+export { AureliaFrameworkFactory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-grid-aurelia-plugin",
-  "version": "31.3.4",
+  "version": "31.3.6",
   "description": "ag-Grid Aurelia Component, a fork of Niall Crosby <niall.crosby@gmail.com>",
   "credits": "Niall Crosby <niall.crosby@gmail.com>",
   "main": "./main.js",