KERNEL-14116 refactor: component/allvaluechooser、allvaluemultitextvaluecombo、form

src/component/allvaluechooser/abstract.allvaluechooser.js

@@ -1,61 +1,74 @@
-/**
+import {
- * 简单的复选下拉框控件, 适用于数据量少的情况， 与valuechooser的区别是allvaluechooser setValue和getValue返回的是所有值
+    shortcut,
- * 封装了字段处理逻辑
+    Widget,
- *
+    extend,
- * Created by GUY on 2015/10/29.
+    emptyFn,
- * @class BI.AbstractAllValueChooser
+    isNotNull,
- * @extends BI.Widget
+    some,
- */
+    isNotEmptyArray,
-BI.AbstractAllValueChooser = BI.inherit(BI.Widget, {
+    each,
+    Func,
+    uniq,
+    makeObject,
+    filter,
+    difference,
+    map,
+    Selection
+} from "@/core";
+import { MultiSelectCombo } from "@/widget";
 
-    _const: {
+@shortcut()
-        perPage: 100
+export class AbstractAllValueChooser extends Widget {
-    },
+    _const = { perPage: 100 };
 
-    _defaultConfig: function () {
+    _defaultConfig() {
-        return BI.extend(BI.AbstractAllValueChooser.superclass._defaultConfig.apply(this, arguments), {
+        return extend(super._defaultConfig(...arguments), {
             width: 200,
             height: 30,
             items: null,
-            itemsCreator: BI.emptyFn,
+            itemsCreator: emptyFn,
-            cache: true
+            cache: true,
         });
-    },
+    }
 
-    _valueFormatter: function (v) {
+    _valueFormatter(v) {
-        var text = v;
+        let text = v;
         if (this.options.valueFormatter) {
             return this.options.valueFormatter(v);
         }
-        if (BI.isNotNull(this.items)) {
+        if (isNotNull(this.items)) {
-            BI.some(this.items, function (i, item) {
+            some(this.items, (i, item) => {
                 // 把value都换成字符串
                 // 需要考虑到value也可能是数字
-                if (item.value === v || item.value + "" === v) {
+                if (item.value === v || `${item.value}` === v) {
                     text = item.text;
+                    
                     return true;
                 }
             });
         }
+        
         return text;
-    },
+    }
 
-    _getItemsByTimes: function (items, times) {
+    _getItemsByTimes(items, times) {
-        var res = [];
+        const res = [];
-        for (var i = (times - 1) * this._const.perPage; items[i] && i < times * this._const.perPage; i++) {
+        for (let i = (times - 1) * this._const.perPage; items[i] && i < times * this._const.perPage; i++) {
             res.push(items[i]);
         }
+        
         return res;
-    },
+    }
 
-    _hasNextByTimes: function (items, times) {
+    _hasNextByTimes(items, times) {
         return times * this._const.perPage < items.length;
-    },
+    }
 
-    _itemsCreator: function (options, callback) {
+    _itemsCreator(options, callback) {
-        var self = this, o = this.options;
+        const self = this,
+            o = this.options;
         if (!o.cache || !this.items) {
-            o.itemsCreator({}, function (items) {
+            o.itemsCreator({}, items => {
                 self.items = items;
                 call(items);
             });
@@ -64,54 +77,56 @@ BI.AbstractAllValueChooser = BI.inherit(BI.Widget, {
         }
 
         function call(items) {
-            var keywords = (options.keywords || []).slice();
+            const keywords = (options.keywords || []).slice();
             if (options.keyword) {
                 keywords.push(options.keyword);
             }
-            var resultItems = items;
+            let resultItems = items;
-            if (BI.isNotEmptyArray(keywords)) {
+            if (isNotEmptyArray(keywords)) {
                 resultItems = [];
-                BI.each(keywords, function (i, kw) {
+                each(keywords, (i, kw) => {
-                    var search = BI.Func.getSearchResult(items, kw);
+                    const search = Func.getSearchResult(items, kw);
                     resultItems = resultItems.concat(search.match).concat(search.find);
                 });
-                resultItems = BI.uniq(resultItems);
+                resultItems = uniq(resultItems);
             }
-            if (options.selectedValues) {// 过滤
+            if (options.selectedValues) {
-                var filter = BI.makeObject(options.selectedValues, true);
+                // 过滤
-                resultItems = BI.filter(resultItems, function (i, ob) {
+                const values = makeObject(options.selectedValues, true);
-                    return !filter[ob.value];
+                resultItems = filter(resultItems, (i, ob) => !values[ob.value]);
-                });
             }
-            if (options.type === BI.MultiSelectCombo.REQ_GET_ALL_DATA) {
+            if (options.type === MultiSelectCombo.REQ_GET_ALL_DATA) {
                 callback({
-                    items: resultItems
+                    items: resultItems,
                 });
+                
                 return;
             }
-            if (options.type === BI.MultiSelectCombo.REQ_GET_DATA_LENGTH) {
+            if (options.type === MultiSelectCombo.REQ_GET_DATA_LENGTH) {
                 callback({ count: resultItems.length });
+                
                 return;
             }
             callback({
                 items: self._getItemsByTimes(resultItems, options.times),
-                hasNext: self._hasNextByTimes(resultItems, options.times)
+                hasNext: self._hasNextByTimes(resultItems, options.times),
             });
         }
-    },
+    }
 
-    _assertValue: function (v) {
+    _assertValue(v) {
         v = v || {};
-        var value = v;
+        let value = v;
-        if (BI.isNotNull(this.items)) {
+        if (isNotNull(this.items)) {
-            var isAllSelect = BI.difference(BI.map(this.items, "value"), v.value).length === 0;
+            const isAllSelect = difference(map(this.items, "value"), v.value).length === 0;
             if (isAllSelect) {
                 value = {
-                    type: BI.Selection.All,
+                    type: Selection.All,
                     value: [],
                 };
             }
         }
+        
         return value;
-    },
+    }
-});
+}

src/component/allvaluechooser/combo.allvaluechooser.js

@@ -1,77 +1,77 @@
-/**
+import { shortcut, extend, emptyFn, isNotNull, createWidget, bind, Selection, difference, map } from "@/core";
- * 简单的复选下拉框控件, 适用于数据量少的情况， 与valuechooser的区别是allvaluechooser setValue和getValue返回的是所有值
+import { AbstractAllValueChooser } from "./abstract.allvaluechooser";
- * 封装了字段处理逻辑
+import { MultiSelectCombo } from "@/widget";
- *
- * Created by GUY on 2015/10/29.
- * @class BI.AllValueChooserCombo
- * @extends BI.AbstractAllValueChooser
- */
-BI.AllValueChooserCombo = BI.inherit(BI.AbstractAllValueChooser, {
 
-    _defaultConfig: function () {
+@shortcut()
-        return BI.extend(BI.AllValueChooserCombo.superclass._defaultConfig.apply(this, arguments), {
+export class AllValueChooserCombo extends AbstractAllValueChooser {
+    static xtype = "bi.all_value_chooser_combo";
+
+    static EVENT_CONFIRM = "EVENT_CONFIRM";
+
+    _defaultConfig() {
+        return extend(super._defaultConfig(...arguments), {
             baseCls: "bi-all-value-chooser-combo",
             width: 200,
             height: 24,
             items: null,
-            itemsCreator: BI.emptyFn,
+            itemsCreator: emptyFn,
-            cache: true
+            cache: true,
         });
-    },
+    }
 
-    _init: function () {
+    _init() {
-        BI.AllValueChooserCombo.superclass._init.apply(this, arguments);
+        super._init(...arguments);
-        var self = this, o = this.options;
+        const o = this.options;
-        if (BI.isNotNull(o.items)) {
+        if (isNotNull(o.items)) {
             this.items = o.items;
         }
-        this.combo = BI.createWidget({
+        this.combo = createWidget({
-            type: "bi.multi_select_combo",
+            type: MultiSelectCombo.xtype,
             simple: o.simple,
             text: o.text,
             element: this,
-            itemsCreator: BI.bind(this._itemsCreator, this),
+            itemsCreator: bind(this._itemsCreator, this),
-            valueFormatter: BI.bind(this._valueFormatter, this),
+            valueFormatter: bind(this._valueFormatter, this),
             width: o.width,
             height: o.height,
             value: this._assertValue({
-                type: BI.Selection.Multi,
+                type: Selection.Multi,
-                value: o.value || []
+                value: o.value || [],
-            })
+            }),
         });
 
-        this.combo.on(BI.MultiSelectCombo.EVENT_CONFIRM, function () {
+        this.combo.on(MultiSelectCombo.EVENT_CONFIRM, () => {
-            self.fireEvent(BI.AllValueChooserCombo.EVENT_CONFIRM);
+            this.fireEvent(AllValueChooserCombo.EVENT_CONFIRM);
         });
-    },
+    }
 
-    setValue: function (v) {
+    setValue(v) {
-        this.combo.setValue(this._assertValue({
+        this.combo.setValue(
-            type: BI.Selection.Multi,
+            this._assertValue({
-            value: v || []
+                type: Selection.Multi,
-        }));
+                value: v || [],
-    },
+            })
+        );
+    }
 
-    getValue: function () {
+    getValue() {
         return this.getAllValue();
-    },
+    }
 
-    getAllValue: function () {
+    getAllValue() {
-        var val = this.combo.getValue() || {};
+        const val = this.combo.getValue() || {};
-        if (val.type === BI.Selection.Multi) {
+        if (val.type === Selection.Multi) {
             return val.value || [];
         }
 
-        return BI.difference(BI.map(this.items, "value"), val.value || []);
+        return difference(map(this.items, "value"), val.value || []);
-    },
+    }
 
-    populate: function (items) {
+    populate(items) {
         // 直接用combo的populate不会作用到AbstractValueChooser上
-        if (BI.isNotNull(items)) {
+        if (isNotNull(items)) {
             this.items = items;
         }
         this.combo.populate();
     }
-});
+}
-BI.AllValueChooserCombo.EVENT_CONFIRM = "EVENT_CONFIRM";
-BI.shortcut("bi.all_value_chooser_combo", BI.AllValueChooserCombo);

src/component/allvaluechooser/index.js

@@ -0,0 +1,3 @@
+export { AbstractAllValueChooser } from "./abstract.allvaluechooser";
+export { AllValueChooserCombo } from "./combo.allvaluechooser";
+export { AllValueChooserPane } from "./pane.allvaluechooser";

src/component/allvaluechooser/pane.allvaluechooser.js

@@ -1,69 +1,67 @@
-/**
+import { shortcut, extend, emptyFn, createWidget, bind, isNotNull, Selection, difference, map } from "@/core";
- * 简单的复选面板, 适用于数据量少的情况， 与valuechooser的区别是allvaluechooser setValue和getValue返回的是所有值
+import { AbstractAllValueChooser } from "./abstract.allvaluechooser";
- * 封装了字段处理逻辑
+import { MultiSelectList } from "@/widget";
- *
- * Created by GUY on 2015/10/29.
- * @class BI.AllValueChooserPane
- * @extends BI.AbstractAllValueChooser
- */
-BI.AllValueChooserPane = BI.inherit(BI.AbstractAllValueChooser, {
 
-    _defaultConfig: function () {
+@shortcut()
-        return BI.extend(BI.AllValueChooserPane.superclass._defaultConfig.apply(this, arguments), {
+export class AllValueChooserPane extends AbstractAllValueChooser {
+    static xtype = "bi.all_value_chooser_pane";
+
+    static EVENT_CHANGE = "EVENT_CHANGE";
+
+    _defaultConfig() {
+        return extend(super._defaultConfig(...arguments), {
             baseCls: "bi-all-value-chooser-pane",
             width: 200,
             height: 30,
             items: null,
-            itemsCreator: BI.emptyFn,
+            itemsCreator: emptyFn,
-            cache: true
+            cache: true,
         });
-    },
+    }
 
-    _init: function () {
+    _init() {
-        BI.AllValueChooserPane.superclass._init.apply(this, arguments);
+        super._init(...arguments);
-        var self = this, o = this.options;
+        const o = this.options;
-        this.list = BI.createWidget({
+        this.list = createWidget({
-            type: "bi.multi_select_list",
+            type: MultiSelectList.xtype,
             element: this,
-            itemsCreator: BI.bind(this._itemsCreator, this),
+            itemsCreator: bind(this._itemsCreator, this),
-            valueFormatter: BI.bind(this._valueFormatter, this),
+            valueFormatter: bind(this._valueFormatter, this),
             width: o.width,
-            height: o.height
+            height: o.height,
         });
 
-        this.list.on(BI.MultiSelectList.EVENT_CHANGE, function () {
+        this.list.on(MultiSelectList.EVENT_CHANGE, () => {
-            self.fireEvent(BI.AllValueChooserPane.EVENT_CHANGE);
+            this.fireEvent(AllValueChooserPane.EVENT_CHANGE);
         });
 
-        if (BI.isNotNull(o.items)) {
+        if (isNotNull(o.items)) {
             this.items = o.items;
             this.list.populate();
         }
-    },
+    }
 
-    setValue: function (v) {
+    setValue(v) {
         this.list.setValue({
-            type: BI.Selection.Multi,
+            type: Selection.Multi,
-            value: v || []
+            value: v || [],
         });
-    },
+    }
 
-    getValue: function () {
+    getValue() {
-        var val = this.list.getValue() || {};
+        const val = this.list.getValue() || {};
-        if (val.type === BI.Selection.Multi) {
+        if (val.type === Selection.Multi) {
             return val.value || [];
         }
 
-        return BI.difference(BI.map(this.items, "value"), val.value || []);
+        return difference(map(this.items, "value"), val.value || []);
-    },
+    }
 
-    populate: function (items) {
+    populate(items) {
         // 直接用combo的populate不会作用到AbstractValueChooser上
-        if (BI.isNotNull(items)) {
+        if (isNotNull(items)) {
             this.items = items;
         }
         this.list.populate();
     }
-});
+}
-BI.AllValueChooserPane.EVENT_CHANGE = "EVENT_CHANGE";
-BI.shortcut("bi.all_value_chooser_pane", BI.AllValueChooserPane);

src/component/allvaluemultitextvaluecombo/allvalue.multitextvalue.combo.js

@@ -1,66 +1,72 @@
-BI.AllValueMultiTextValueCombo = BI.inherit(BI.Widget, {
+import { shortcut, Widget, Selection, each, contains } from "@/core";
+import { SearchMultiTextValueCombo } from "@/widget";
 
-    props: {
+@shortcut()
-        baseCls: "bi-all-value-multi-text-value-combo",
+export class AllValueMultiTextValueCombo extends Widget {
-        width: 200,
+    static xtype = "bi.all_value_multi_text_value_combo";
-        height: 24,
-        items: []
-    },
 
-    render: function () {
+    props = { baseCls: "bi-all-value-multi-text-value-combo", width: 200, height: 24, items: [] };
-        var self = this, o = this.options;
+
-        var value = this._digestValue(o.value);
+    static EVENT_CONFIRM = "EVENT_CONFIRM";
+
+    render() {
+        const self = this,
+            o = this.options;
+        const value = this._digestValue(o.value);
+        
         return {
             type: "bi.search_multi_text_value_combo",
             simple: o.simple,
             text: o.text,
             height: o.height,
             items: o.items,
-            value: value,
+            value,
             numOfPage: 100,
             valueFormatter: o.valueFormatter,
             warningTitle: o.warningTitle,
-            listeners: [{
+            listeners: [
-                eventName: BI.SearchMultiTextValueCombo.EVENT_CONFIRM,
+                {
-                action: function () {
+                    eventName: SearchMultiTextValueCombo.EVENT_CONFIRM,
-                    self.fireEvent(BI.AllValueMultiTextValueCombo.EVENT_CONFIRM);
+                    action () {
+                        self.fireEvent(AllValueMultiTextValueCombo.EVENT_CONFIRM);
+                    },
                 }
-            }],
+            ],
-            ref: function () {
+            ref () {
                 self.combo = this;
-            }
+            },
         };
-    },
+    }
 
-    setValue: function (v) {
+    setValue(v) {
-        var value = this._digestValue(v);
+        const value = this._digestValue(v);
         this.combo.setValue(value);
-    },
+    }
 
-    getValue: function () {
+    getValue() {
-        var obj = this.combo.getValue() || {};
+        const obj = this.combo.getValue() || {};
         obj.value = obj.value || [];
-        if(obj.type === BI.Selection.All) {
+        if (obj.type === Selection.All) {
-            var values = [];
+            const values = [];
-            BI.each(this.options.items, function (idx, item) {
+            each(this.options.items, (idx, item) => {
-                !BI.contains(obj.value, item.value) && values.push(item.value);
+                !contains(obj.value, item.value) && values.push(item.value);
             });
+            
             return values;
         }
+        
         return obj.value || [];
-    },
+    }
 
-    populate: function (items) {
+    populate(items) {
         this.options.items = items;
-        this.combo.populate.apply(this.combo, arguments);
+        this.combo.populate(...arguments);
-    },
+    }
 
-    _digestValue: function (v) {
+    _digestValue(v) {
         return {
-            type: BI.Selection.Multi,
+            type: Selection.Multi,
-            value: v || []
+            value: v || [],
         };
     }
-});
+}
-BI.AllValueMultiTextValueCombo.EVENT_CONFIRM = "EVENT_CONFIRM";
-BI.shortcut("bi.all_value_multi_text_value_combo", BI.AllValueMultiTextValueCombo);

src/component/form/form.field.js

@@ -1,98 +1,111 @@
-/**
- * @author windy
- * @version 2.0
- * Created by windy on 2022/1/11
- */
- BI.FormField = BI.inherit(BI.Widget, {
 
-    props: {
+import { shortcut, Widget, extend, concat, isKey, VerticalAlign } from "@/core";
+
+@shortcut()
+export class FormField extends Widget {
+    static xtype = "bi.form_field";
+
+    props = {
         baseCls: "bi-form-field",
         label: "",
         el: {},
         headerCls: "",
         labelAlign: "right", // 文字默认右对齐
-        validate: function () {
+        validate () {
             return true;
-        } // 默认返回true
+        }, // 默认返回true
-    },
+    }
 
-    render: function () {
+    render () {
-        var self = this, o = this.options;
+        const self = this,
+            o = this.options;
 
-        var field = {
+        const field = {
             type: "bi.absolute",
-            items: [{
+            items: [
-                el: BI.extend({}, o.el, {
+                {
-                    ref: function (_ref) {
+                    el: extend({}, o.el, {
-                        self.field = _ref;
+                        ref (_ref) {
-                        o.el.ref && o.el.ref.call(this, _ref);
+                            self.field = _ref;
-                    },
+                            o.el.ref && o.el.ref.call(this, _ref);
-                    height: o.el.height || 28,
+                        },
-                    listeners: BI.concat(o.el.listeners, [{
+                        height: o.el.height || 28,
-                        eventName: "EVENT_CHANGE",
+                        listeners: concat(o.el.listeners, [
-                        action: function () {
+                            {
-                            self.fireEvent("EVENT_CHANGE");
+                                eventName: "EVENT_CHANGE",
-                        }
+                                action () {
-                    }, {
+                                    self.fireEvent("EVENT_CHANGE");
-                        eventName: "EVENT_CONFIRM",
+                                },
-                        action: function () {
+                            },
-                            self.fireEvent("EVENT_CONFIRM");
+                            {
-                        }
+                                eventName: "EVENT_CONFIRM",
-                    }])
+                                action () {
-                }),
+                                    self.fireEvent("EVENT_CONFIRM");
-                left: 0,
+                                },
-                bottom: 0,
+                            }
-                right: 0,
+                        ]),
-                top: 0
+                    }),
-            }, {
+                    left: 0,
-                el: {
+                    bottom: 0,
-                    type: "bi.label",
+                    right: 0,
-                    cls: "error-tip bi-error",
+                    top: 0,
-                    ref: function (_ref) {
-                        self.error = _ref;
-                    },
-                    invisible: true
                 },
-                bottom: -20,
+                {
-                left: 0,
+                    el: {
-                right: 0,
+                        type: "bi.label",
-                height: 20
+                        cls: "error-tip bi-error",
-            }]
+                        ref (_ref) {
+                            self.error = _ref;
+                        },
+                        invisible: true,
+                    },
+                    bottom: -20,
+                    left: 0,
+                    right: 0,
+                    height: 20,
+                }
+            ],
         };
 
         return {
             type: "bi.vertical_adapt",
             columnSize: ["auto", "fill"],
-            verticalAlign: BI.VerticalAlign.Stretch,
+            verticalAlign: VerticalAlign.Stretch,
-            items: BI.isKey(o.label) ? [{
+            items: isKey(o.label)
-                el: {
+                ? [
-                    type: "bi.label",
+                    {
-                    textAlign: o.labelAlign,
+                        el: {
-                    text: o.label,
+                            type: "bi.label",
-                    width: o.labelWidth,
+                            textAlign: o.labelAlign,
-                    cls: o.headerCls,
+                            text: o.label,
-                    rgap: 20 // 表单文字与右侧输入间距均为20px
+                            width: o.labelWidth,
-                }
+                            cls: o.headerCls,
-            }, field] : [field]
+                            rgap: 20, // 表单文字与右侧输入间距均为20px
+                        },
+                    },
+                    field
+                ]
+                : [field],
         };
-    },
+    }
 
-    getValue: function () {
+    getValue () {
         return this.field.getValue();
-    },
+    }
 
-    validate: function () {
+    validate () {
-        var isValid = this.validateWithNoTip();
+        const isValid = this.validateWithNoTip();
-        !isValid && this.error.setText(this.options.tip(this.field.getValue(), this.field));
+        !isValid &&
+            this.error.setText(
+                this.options.tip(this.field.getValue(), this.field)
+            );
         this.error.setVisible(!isValid);
         this.field.element[isValid ? "removeClass" : "addClass"]("bi-error");
 
         return isValid;
-    },
+    }
 
-    validateWithNoTip: function () {
+    validateWithNoTip () {
         return this.options.validate(this.field.getValue(), this.field);
     }
-});
+}
-
-BI.shortcut("bi.form_field", BI.FormField);

src/component/form/form.js

@@ -1,45 +1,39 @@
-/**
+import { shortcut, Widget, map, some, each } from "@/core";
- * @author windy
+import { ButtonGroup } from "@/base";
- * @version 2.0
- * Created by windy on 2022/1/11
- */
- BI.Form = BI.inherit(BI.Widget, {
 
-    props: {
+@shortcut()
+export class Form extends Widget {
+    static xtype = "bi.custom_form";
+
+    props = {
         baseCls: "bi-form",
         labelAlign: "right",
-        layout: {
+        layout: { type: "bi.vertical", vgap: 20 },
-            type: "bi.vertical",
+        items: [{ label: "", el: {} }],
-            vgap: 20
-        },
-        items: [{
-            validate: BI.emptyFn,
-            tip: BI.emptyFn,
-            label: "",
-            el: {}
-        }],
         labelWidth: "",
-        headerCls: "", // 左侧文字样式
+        headerCls: "",
-    },
+    };
+
+    static EVENT_CHANGE = "EVENT_CHANGE";
 
-    render: function () {
+    render() {
-        var self = this, o = this.options;
+        const o = this.options;
 
         return {
-            type: "bi.button_group",
+            type: ButtonGroup.xtype,
             items: this._createItems(),
             layouts: [o.layout],
-            ref: function (ref) {
+            ref: _ref => {
-                self.group = ref;
+                this.group = _ref;
-            }
+            },
         };
-    },
+    }
 
-    _createItems: function () {
+    _createItems() {
-        var self = this;
+        const self = this;
-        var o = this.options;
+        const o = this.options;
 
-        return BI.map(o.items, function (idx, item) {
+        return map(o.items, (idx, item) => {
             return {
                 type: "bi.form_field",
                 height: item.el.height || 28,
@@ -50,46 +44,43 @@
                 label: item.label,
                 tip: item.tip,
                 validate: item.validate,
-                listeners: [{
+                listeners: [
-                    eventName: "EVENT_CHANGE",
+                    {
-                    action: function () {
+                        eventName: "EVENT_CHANGE",
-                        self.fireEvent(BI.Form.EVENT_CHANGE, this.validate());
+                        action () {
+                            self.fireEvent(Form.EVENT_CHANGE, this.validate());
+                        },
                     }
-                }]
+                ],
             };
         });
-    },
+    }
 
-    isAllValid: function () {
+    isAllValid() {
-        return !BI.some(this.validateWithNoTip(), function (idx, v) {
+        return !some(this.validateWithNoTip(), (idx, v) => !v);
-            return !v;
+    }
-        });
-    },
 
-    validateWithNoTip: function () {
+    validateWithNoTip() {
-        var validInfo = [];
+        const validInfo = [];
-        BI.each(this.group.getAllButtons(), function (idx, button) {
+        each(this.group.getAllButtons(), (idx, button) => {
             validInfo.push(button.validateWithNoTip());
         });
 
         return validInfo;
-    },
+    }
 
-    validate: function () {
+    validate() {
-        var validInfo = [];
+        const validInfo = [];
-        BI.each(this.group.getAllButtons(), function (idx, button) {
+        each(this.group.getAllButtons(), (idx, button) => {
             validInfo.push(button.validate());
         });
 
         return validInfo;
-    },
-
-    getValue: function () {
-        return !this.isAllValid() ? null : BI.map(this.group.getAllButtons(), function (idx, button) {
-            return button.getValue();
-        });
     }
-});
 
-BI.Form.EVENT_CHANGE = "EVENT_CHANGE";
+    getValue() {
-BI.shortcut("bi.custom_form", BI.Form);
+        return !this.isAllValid()
+            ? null
+            : map(this.group.getAllButtons(), (idx, button) => button.getValue());
+    }
+}

src/component/form/index.js

@@ -0,0 +1,2 @@
+export { Form } from "./form";
+export { FormField } from "./form.field";

src/component/index.js

@@ -0,0 +1,15 @@
+import * as allvaluechooser from "./allvaluechooser";
+import * as form from "./form";
+import { AllValueMultiTextValueCombo } from "./allvaluemultitextvaluecombo/allvalue.multitextvalue.combo";
+
+Object.assign(BI, {
+    ...allvaluechooser,
+    ...form,
+    AllValueMultiTextValueCombo,
+});
+
+export * from "./allvaluechooser";
+export * from "./form";
+export {
+    AllValueMultiTextValueCombo
+};