aurelia-syncfusion-ej2-bridge 0.1.0-beta.25 → 0.1.0-beta.26

package/dist/commonjs/common/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const constants: {
+    eventPrefix: string;
+    bindablePrefix: string;
+};

package/dist/commonjs/common/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = void 0;
+exports.constants = {
+    eventPrefix: 'e-on-',
+    bindablePrefix: 'e-'
+};

package/dist/commonjs/common/controlBase.d.ts

@@ -0,0 +1,37 @@
+import { TaskQueue } from 'aurelia-task-queue';
+import { BindingEngine, Disposable } from "aurelia-framework";
+import { ControlContainer, Control } from "./controlContainer";
+import { EventAggregator } from 'aurelia-event-aggregator';
+export declare class ControlBase<T, U> {
+    protected bindingEngine: BindingEngine;
+    private controlContainer;
+    protected taskQueue: TaskQueue;
+    protected eventAggregator: EventAggregator;
+    protected element: Element;
+    private eModel;
+    protected _eModel: U;
+    protected widgetElement: HTMLElement;
+    widget: T;
+    protected bindingContext: any;
+    protected logName: string;
+    private propertyPriority;
+    protected get controlType(): Function;
+    protected subscriptions: Disposable[];
+    constructor(bindingEngine: BindingEngine, controlContainer: ControlContainer, taskQueue: TaskQueue, eventAggregator: EventAggregator, element: Element);
+    onBind(): void;
+    onAttached(): void;
+    onCreateControl(): void;
+    protected debug(message: string, ...rest: any[]): void;
+    protected info(message: string, ...rest: any[]): void;
+    protected error(message: string, ...rest: any[]): void;
+    protected warn(message: string, ...rest: any[]): void;
+    bind(context: any): void;
+    protected setInitialBindings(): void;
+    getBindables(): Control;
+    createControlEvents(control: Control): void;
+    createControlPropertySubscriptions(control: Control): void;
+    attached(): void;
+    protected appendWidget(): void;
+    detached(): void;
+}
+export declare const ExcludedProperties: string[];

package/dist/commonjs/common/controlBase.js

@@ -0,0 +1,162 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcludedProperties = exports.ControlBase = void 0;
+const aurelia_task_queue_1 = require("aurelia-task-queue");
+const aurelia_framework_1 = require("aurelia-framework");
+const controlContainer_1 = require("./controlContainer");
+const constants_1 = require("./constants");
+const aurelia_event_aggregator_1 = require("aurelia-event-aggregator");
+let logger = aurelia_framework_1.LogManager.getLogger("SyncfusionBridge");
+let ControlBase = class ControlBase {
+    constructor(bindingEngine, controlContainer, taskQueue, eventAggregator, element) {
+        this.bindingEngine = bindingEngine;
+        this.controlContainer = controlContainer;
+        this.taskQueue = taskQueue;
+        this.eventAggregator = eventAggregator;
+        this.element = element;
+        this.eModel = null;
+        this._eModel = null;
+        this.widgetElement = null;
+        this.widget = null;
+        this.bindingContext = null;
+        this.logName = "";
+        this.propertyPriority = true;
+        this.subscriptions = [];
+    }
+    get controlType() {
+        throw "syncfusionControlType is not set";
+    }
+    onBind() {
+    }
+    onAttached() {
+    }
+    onCreateControl() {
+        throw "onCreateControl is not implemented";
+    }
+    debug(message, ...rest) {
+        logger.debug(`[${this.logName}] - ${message}`, rest);
+    }
+    info(message, ...rest) {
+        logger.info(`[${this.logName}] - ${message}`, rest);
+    }
+    error(message, ...rest) {
+        logger.error(`[${this.logName}] - ${message}`, rest);
+    }
+    warn(message, ...rest) {
+        logger.warn(`[${this.logName}] - ${message}`, rest);
+    }
+    bind(context) {
+        this.logName = this.controlType.name;
+        this.bindingContext = context;
+        this._eModel = Object.assign({}, this.eModel);
+        this.setInitialBindings();
+        this.onCreateControl();
+        this.onBind();
+    }
+    setInitialBindings() {
+        let _control = this.getBindables();
+        let bindablePrefixLength = constants_1.constants.bindablePrefix.length;
+        _control.bindableProperties.forEach((property) => {
+            if (!property.startsWith(constants_1.constants.eventPrefix)) {
+                let modelProperty = property.substr(bindablePrefixLength);
+                if (this[property] !== undefined && (this.propertyPriority || this._eModel[modelProperty] === undefined)) {
+                    this._eModel[modelProperty] = this[property];
+                }
+            }
+        });
+        this.createControlPropertySubscriptions(_control);
+    }
+    getBindables() {
+        let _control = this.controlContainer.get(this.controlType);
+        if (!_control) {
+            _control = {};
+            _control.type = this.controlType;
+            _control.bindableProperties = [];
+            _control.bindableEvents = [];
+            for (let property in this["__observers__"]) {
+                if (exports.ExcludedProperties.indexOf(property) === -1) {
+                    if (property.startsWith(constants_1.constants.eventPrefix)) {
+                        _control.bindableEvents.push(property);
+                    }
+                    else {
+                        _control.bindableProperties.push(property);
+                    }
+                }
+            }
+        }
+        return _control;
+    }
+    createControlEvents(control) {
+        control.bindableEvents.forEach((event) => {
+            let eventName = event.substr(constants_1.constants.eventPrefix.length);
+            this.widget.addEventListener(eventName, (args) => {
+                this.element.dispatchEvent(new CustomEvent(event, {
+                    bubbles: true,
+                    detail: args
+                }));
+            });
+        });
+    }
+    createControlPropertySubscriptions(control) {
+        if (control) {
+            let bindablePrefixLength = constants_1.constants.bindablePrefix.length;
+            control.bindableProperties.forEach((binding) => {
+                let modelBinding = binding.substr(bindablePrefixLength);
+                this.subscriptions.push(this.bindingEngine.propertyObserver(this, binding).subscribe((newValue) => {
+                    if (this.widget.properties.hasOwnProperty(modelBinding)) {
+                        let customFunc = `${modelBinding}Changed`;
+                        if (typeof this[customFunc] === "function") {
+                            this[customFunc].call(this, newValue);
+                        }
+                        else {
+                            this.widget[modelBinding] = newValue;
+                        }
+                    }
+                }));
+            });
+        }
+    }
+    attached() {
+        this.appendWidget();
+        this.onAttached();
+    }
+    appendWidget() {
+        this.widget.appendTo(this.widgetElement);
+    }
+    detached() {
+        this.subscriptions.forEach((subscription) => { if (subscription) {
+            subscription.dispose();
+        } });
+        if (this.widget.destroy) {
+            this.debug("destroy method", null);
+            this.widget.destroy();
+        }
+        this.widget = null;
+        this._eModel = null;
+        this.widgetElement = null;
+    }
+};
+__decorate([
+    aurelia_framework_1.bindable,
+    __metadata("design:type", Object)
+], ControlBase.prototype, "eModel", void 0);
+ControlBase = __decorate([
+    aurelia_framework_1.autoinject,
+    __metadata("design:paramtypes", [aurelia_framework_1.BindingEngine, controlContainer_1.ControlContainer,
+        aurelia_task_queue_1.TaskQueue, aurelia_event_aggregator_1.EventAggregator, Element])
+], ControlBase);
+exports.ControlBase = ControlBase;
+exports.ExcludedProperties = [
+    "__propertiesDefined__",
+    "eModel",
+    "onClick"
+];

package/dist/commonjs/common/controlContainer.d.ts

@@ -0,0 +1,10 @@
+export declare class ControlContainer {
+    controls: Control[];
+    add(control: Control): void;
+    get(type: Function): Control;
+}
+export interface Control {
+    type: Function;
+    bindableProperties: string[];
+    bindableEvents: string[];
+}

package/dist/commonjs/common/controlContainer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlContainer = void 0;
+class ControlContainer {
+    constructor() {
+        this.controls = [];
+    }
+    add(control) {
+        let existing = this.controls.find((x) => x.type === control.type);
+        if (!existing) {
+            this.controls.push(control);
+        }
+    }
+    get(type) {
+        let _control = this.controls.find((x) => x.type === type);
+        return _control;
+    }
+}
+exports.ControlContainer = ControlContainer;

package/dist/commonjs/common/syncfusionWrapper.d.ts

@@ -0,0 +1,15 @@
+import { ControlBase } from "./controlBase";
+export declare abstract class SyncfusionWrapper<T, U> extends ControlBase<T, U> {
+    protected abstract syncfusionWidgetType: any;
+    protected abstract onWrapperCreated(): any;
+    protected abstract onWidgetCreated(): any;
+    onCreateControl(): void;
+    recreate(): void;
+    onRecreate(): void;
+    recreating(): void;
+    recreated(): void;
+    refresh(): void;
+    dataBind(): void;
+    protected get controlType(): any;
+    protected onBeforeWidgetInstantiation(): void;
+}

package/dist/commonjs/common/syncfusionWrapper.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncfusionWrapper = void 0;
+const controlBase_1 = require("./controlBase");
+class SyncfusionWrapper extends controlBase_1.ControlBase {
+    constructor() {
+        super(...arguments);
+        this.syncfusionWidgetType = null;
+    }
+    onCreateControl() {
+        this.onBeforeWidgetInstantiation();
+        this.widget = new this.syncfusionWidgetType(this._eModel);
+        this.widget.created = () => { this.onWidgetCreated(); };
+        this.onWrapperCreated();
+        this.createControlEvents(this.getBindables());
+    }
+    recreate() {
+        this.onRecreate();
+        this.widget.destroy();
+        this.widget = null;
+        this.recreating();
+        this.setInitialBindings();
+        this.onCreateControl();
+        this.appendWidget();
+        this.recreated();
+    }
+    onRecreate() {
+    }
+    recreating() {
+    }
+    recreated() {
+    }
+    refresh() {
+        this.widget.refresh();
+    }
+    dataBind() {
+        this.widget.dataBind();
+    }
+    get controlType() {
+        if (this.syncfusionWidgetType) {
+            return this.syncfusionWidgetType;
+        }
+        throw "syncfusionControlType is not set";
+    }
+    onBeforeWidgetInstantiation() {
+    }
+}
+exports.SyncfusionWrapper = SyncfusionWrapper;

package/dist/commonjs/configBuider.d.ts

@@ -0,0 +1,39 @@
+export declare class ConfigBuilder {
+    resources: any[];
+    useGlobalResources: boolean;
+    useAll(): ConfigBuilder;
+    useDefaults(): ConfigBuilder;
+    useTheme(theme: "material" | "bootstrap" | "bootstrap4" | "fabric" | "highcontrast"): this;
+    materialTheme(): this;
+    withoutGlobalResources(): ConfigBuilder;
+    ej2Accordion(): ConfigBuilder;
+    ej2AutoComplete(): ConfigBuilder;
+    ej2Button(): ConfigBuilder;
+    ej2Checkbox(): ConfigBuilder;
+    ej2CheckboxList(): ConfigBuilder;
+    ej2ComboBox(): ConfigBuilder;
+    ej2DashboardLayout(): ConfigBuilder;
+    ej2DatePicker(): ConfigBuilder;
+    ej2DateRangePicker(): ConfigBuilder;
+    ej2DateTimePicker(): ConfigBuilder;
+    ej2DropDownList(): ConfigBuilder;
+    ej2DropDownTree(): ConfigBuilder;
+    ej2FileManager(): ConfigBuilder;
+    ej2Grid(): ConfigBuilder;
+    ej2ListView(): ConfigBuilder;
+    ej2MaskedTextBox(): ConfigBuilder;
+    ej2MultiSelect(): ConfigBuilder;
+    ej2NumericTextBox(): ConfigBuilder;
+    ej2Pager(): ConfigBuilder;
+    ej2ProgressButton(): ConfigBuilder;
+    ej2Radio(): ConfigBuilder;
+    ej2Schedule(): ConfigBuilder;
+    ej2Sidebar(): ConfigBuilder;
+    ej2Slider(): ConfigBuilder;
+    ej2Splitter(): ConfigBuilder;
+    ej2Switch(): ConfigBuilder;
+    ej2TextBox(): ConfigBuilder;
+    ej2TimePicker(): ConfigBuilder;
+    ej2TreeView(): ConfigBuilder;
+    ej2Uploader(): ConfigBuilder;
+}

package/dist/commonjs/configBuider.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigBuilder = void 0;
+const ej2_multiSelect_1 = require("./widgets/multiSelect/ej2-multiSelect");
+const ej2_schedule_1 = require("./widgets/schedule/ej2-schedule");
+const ej2_fileManager_1 = require("./widgets/fileManager/ej2-fileManager");
+const ej2_sidebar_1 = require("./widgets/sidebar/ej2-sidebar");
+const ej2_DatePicker_1 = require("./widgets/datePicker/ej2-DatePicker");
+const aurelia_pal_1 = require("aurelia-pal");
+const ej2_textBox_1 = require("./widgets/textBox/ej2-textBox");
+const ej2_dateRangePicker_1 = require("./widgets/dateRangePicker/ej2-dateRangePicker");
+const ej2_dateTimePicker_1 = require("./widgets/dateTimePicker/ej2-dateTimePicker");
+const ej2_dashboardLayout_1 = require("./widgets/dashboardLayout/ej2-dashboardLayout");
+const ej2_comboBox_1 = require("./widgets/comboBox/ej2-comboBox");
+const ej2_checkbox_list_1 = require("./widgets/checkbox/ej2-checkbox-list");
+const ej2_checkbox_1 = require("./widgets/checkbox/ej2-checkbox");
+const ej2_button_1 = require("./widgets/button/ej2-button");
+const ej2_autoComplete_1 = require("./widgets/autoComplete/ej2-autoComplete");
+const ej2_accordion_1 = require("./widgets/accordion/ej2-accordion");
+const ej2_dropDownList_1 = require("./widgets/dropDownList/ej2-dropDownList");
+const ej2_grid_1 = require("./widgets/grid/ej2-grid");
+const ej2_listView_1 = require("./widgets/listView/ej2-listView");
+const ej2_maskedTextBox_1 = require("./widgets/maskedTextBox/ej2-maskedTextBox");
+const ej2_numericTextBox_1 = require("./widgets/numericTextBox/ej2-numericTextBox");
+const ej2_pager_1 = require("./widgets/pager/ej2-pager");
+const ej2_progress_button_1 = require("./widgets/progressButton/ej2-progress-button");
+const ej2_radio_1 = require("./widgets/radio/ej2-radio");
+const ej2_slider_1 = require("./widgets/slider/ej2-slider");
+const ej2_switch_1 = require("./widgets/switch/ej2-switch");
+const ej2_timePicker_1 = require("./widgets/timePicker/ej2-timePicker");
+const ej2_treeView_1 = require("./widgets/treeView/ej2-treeView");
+const ej2_uploader_1 = require("./widgets/uploader/ej2-uploader");
+const ej2_splitter_1 = require("./widgets/splitter/ej2-splitter");
+const ej2_dropDownTree_1 = require("./widgets/dropDownTree/ej2-dropDownTree");
+class ConfigBuilder {
+    constructor() {
+        this.resources = [];
+        this.useGlobalResources = true;
+    }
+    useAll() {
+        this
+            .ej2Accordion()
+            .ej2AutoComplete()
+            .ej2Button()
+            .ej2Checkbox()
+            .ej2CheckboxList()
+            .ej2ComboBox()
+            .ej2DatePicker()
+            .ej2DateRangePicker()
+            .ej2DateTimePicker()
+            .ej2DashboardLayout()
+            .ej2DropDownList()
+            .ej2DropDownTree()
+            .ej2FileManager()
+            .ej2Grid()
+            .ej2ListView()
+            .ej2MaskedTextBox()
+            .ej2MultiSelect()
+            .ej2NumericTextBox()
+            .ej2Pager()
+            .ej2ProgressButton()
+            .ej2Radio()
+            .ej2Schedule()
+            .ej2Sidebar()
+            .ej2Slider()
+            .ej2Splitter()
+            .ej2Switch()
+            .ej2TextBox()
+            .ej2TimePicker()
+            .ej2TreeView()
+            .ej2Uploader();
+        return this;
+    }
+    useDefaults() {
+        return this.useAll().useTheme("material");
+    }
+    useTheme(theme) {
+        switch (theme) {
+            case "material":
+                return this.materialTheme();
+            default:
+                return this;
+        }
+    }
+    materialTheme() {
+        this.resources.push(aurelia_pal_1.PLATFORM.moduleName("@syncfusion/ej2/material.css"));
+        return this;
+    }
+    withoutGlobalResources() {
+        this.useGlobalResources = false;
+        return this;
+    }
+    ej2Accordion() {
+        this.resources.push(ej2_accordion_1.Ej2Accordion);
+        return this;
+    }
+    ej2AutoComplete() {
+        this.resources.push(ej2_autoComplete_1.Ej2AutoComplete);
+        return this;
+    }
+    ej2Button() {
+        this.resources.push(ej2_button_1.Ej2Button);
+        return this;
+    }
+    ej2Checkbox() {
+        this.resources.push(ej2_checkbox_1.Ej2Checkbox);
+        return this;
+    }
+    ej2CheckboxList() {
+        this.resources.push(ej2_checkbox_list_1.Ej2CheckboxList);
+        return this;
+    }
+    ej2ComboBox() {
+        this.resources.push(ej2_comboBox_1.Ej2ComboBox);
+        return this;
+    }
+    ej2DashboardLayout() {
+        this.resources.push(ej2_dashboardLayout_1.Ej2DashboardLayout);
+        return this;
+    }
+    ej2DatePicker() {
+        this.resources.push(ej2_DatePicker_1.Ej2DatePicker);
+        return this;
+    }
+    ej2DateRangePicker() {
+        this.resources.push(ej2_dateRangePicker_1.Ej2DateRangePicker);
+        return this;
+    }
+    ej2DateTimePicker() {
+        this.resources.push(ej2_dateTimePicker_1.Ej2DateTimePicker);
+        return this;
+    }
+    ej2DropDownList() {
+        this.resources.push(ej2_dropDownList_1.Ej2DropDownList);
+        return this;
+    }
+    ej2DropDownTree() {
+        this.resources.push(ej2_dropDownTree_1.Ej2DropDownTree);
+        return this;
+    }
+    ej2FileManager() {
+        this.resources.push(ej2_fileManager_1.Ej2FileManager);
+        return this;
+    }
+    ej2Grid() {
+        this.resources.push(ej2_grid_1.Ej2Grid);
+        return this;
+    }
+    ej2ListView() {
+        this.resources.push(ej2_listView_1.Ej2ListView);
+        return this;
+    }
+    ej2MaskedTextBox() {
+        this.resources.push(ej2_maskedTextBox_1.Ej2MaskedTextBox);
+        return this;
+    }
+    ej2MultiSelect() {
+        this.resources.push(ej2_multiSelect_1.Ej2MultiSelect);
+        return this;
+    }
+    ej2NumericTextBox() {
+        this.resources.push(ej2_numericTextBox_1.Ej2NumericTextBox);
+        return this;
+    }
+    ej2Pager() {
+        this.resources.push(ej2_pager_1.Ej2Pager);
+        return this;
+    }
+    ej2ProgressButton() {
+        this.resources.push(ej2_progress_button_1.Ej2ProgressButton);
+        return this;
+    }
+    ej2Radio() {
+        this.resources.push(ej2_radio_1.Ej2Radio);
+        return this;
+    }
+    ej2Schedule() {
+        this.resources.push(ej2_schedule_1.Ej2Schedule);
+        return this;
+    }
+    ej2Sidebar() {
+        this.resources.push(ej2_sidebar_1.Ej2Sidebar);
+        return this;
+    }
+    ej2Slider() {
+        this.resources.push(ej2_slider_1.Ej2Slider);
+        return this;
+    }
+    ej2Splitter() {
+        this.resources.push(ej2_splitter_1.Ej2Splitter);
+        return this;
+    }
+    ej2Switch() {
+        this.resources.push(ej2_switch_1.Ej2Switch);
+        return this;
+    }
+    ej2TextBox() {
+        this.resources.push(ej2_textBox_1.Ej2TextBox);
+        return this;
+    }
+    ej2TimePicker() {
+        this.resources.push(ej2_timePicker_1.Ej2TimePicker);
+        return this;
+    }
+    ej2TreeView() {
+        this.resources.push(ej2_treeView_1.Ej2TreeView);
+        return this;
+    }
+    ej2Uploader() {
+        this.resources.push(ej2_uploader_1.Ej2Uploader);
+        return this;
+    }
+}
+exports.ConfigBuilder = ConfigBuilder;