devextreme-vue/gantt.js

DevExtreme Vue UI and Visualization Components

/*!
 * devextreme-vue
 * Version: 19.2.6
 * Build date: Thu Jan 30 2020
 *
 * Copyright (c) 2012 - 2020 Developer Express Inc. ALL RIGHTS RESERVED
 *
 * This software may be modified and distributed under the terms
 * of the MIT license. See the LICENSE file in the root of the project for details.
 *
 * https://github.com/DevExpress/devextreme-vue
 */

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var VueType = require("vue");
var Vue = VueType.default || VueType;
var gantt_1 = require("devextreme/ui/gantt");
var component_1 = require("./core/component");
var configuration_component_1 = require("./core/configuration-component");
var DxGantt = Vue.extend({
    extends: component_1.DxComponent,
    props: {
        accessKey: String,
        activeStateEnabled: Boolean,
        allowSelection: Boolean,
        columns: Array,
        dependencies: Object,
        disabled: Boolean,
        editing: Object,
        elementAttr: Object,
        focusStateEnabled: Boolean,
        height: [Function, Number, String],
        hint: String,
        hoverStateEnabled: Boolean,
        onContentReady: Function,
        onDisposing: Function,
        onInitialized: Function,
        onOptionChanged: Function,
        onSelectionChanged: Function,
        resourceAssignments: Object,
        resources: Object,
        scaleType: String,
        selectedRowKey: {},
        showResources: Boolean,
        showRowLines: Boolean,
        tabIndex: Number,
        taskListWidth: Number,
        tasks: Object,
        taskTitlePosition: String,
        visible: Boolean,
        width: [Function, Number, String]
    },
    computed: {
        instance: function () {
            return this.$_instance;
        }
    },
    beforeCreate: function () {
        this.$_WidgetClass = gantt_1.default;
        this.$_expectedChildren = {
            column: { isCollectionItem: true, optionName: "columns" },
            dependencies: { isCollectionItem: false, optionName: "dependencies" },
            editing: { isCollectionItem: false, optionName: "editing" },
            resourceAssignments: { isCollectionItem: false, optionName: "resourceAssignments" },
            resources: { isCollectionItem: false, optionName: "resources" },
            tasks: { isCollectionItem: false, optionName: "tasks" }
        };
    }
});
exports.DxGantt = DxGantt;
var DxAsyncRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        message: String,
        reevaluate: Boolean,
        type: String,
        validationCallback: Function
    }
});
exports.DxAsyncRule = DxAsyncRule;
DxAsyncRule.$_optionName = "validationRules";
DxAsyncRule.$_isCollectionItem = true;
DxAsyncRule.$_predefinedProps = {
    type: "async"
};
var DxButton = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        cssClass: String,
        hint: String,
        icon: String,
        name: String,
        onClick: [Function, String],
        template: {},
        text: String,
        visible: [Boolean, Function]
    }
});
exports.DxButton = DxButton;
DxButton.$_optionName = "buttons";
DxButton.$_isCollectionItem = true;
var DxColumn = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        alignment: String,
        allowEditing: Boolean,
        allowFiltering: Boolean,
        allowFixing: Boolean,
        allowHeaderFiltering: Boolean,
        allowHiding: Boolean,
        allowReordering: Boolean,
        allowResizing: Boolean,
        allowSearch: Boolean,
        allowSorting: Boolean,
        buttons: Array,
        calculateCellValue: Function,
        calculateDisplayValue: [Function, String],
        calculateFilterExpression: Function,
        calculateSortValue: [Function, String],
        caption: String,
        cellTemplate: {},
        columns: Array,
        cssClass: String,
        customizeText: Function,
        dataField: String,
        dataType: String,
        editCellTemplate: {},
        editorOptions: Object,
        encodeHtml: Boolean,
        falseText: String,
        filterOperations: Array,
        filterType: String,
        filterValue: {},
        filterValues: Array,
        fixed: Boolean,
        fixedPosition: String,
        format: [Object, Function, String],
        formItem: Object,
        headerCellTemplate: {},
        headerFilter: Object,
        hidingPriority: Number,
        isBand: Boolean,
        lookup: Object,
        minWidth: Number,
        name: String,
        ownerBand: Number,
        renderAsync: Boolean,
        selectedFilterOperation: String,
        setCellValue: Function,
        showEditorAlways: Boolean,
        showInColumnChooser: Boolean,
        sortIndex: Number,
        sortingMethod: Function,
        sortOrder: String,
        trueText: String,
        type: String,
        validationRules: Array,
        visible: Boolean,
        visibleIndex: Number,
        width: [Number, String]
    }
});
exports.DxColumn = DxColumn;
DxColumn.$_optionName = "columns";
DxColumn.$_isCollectionItem = true;
DxColumn.$_expectedChildren = {
    AsyncRule: { isCollectionItem: true, optionName: "validationRules" },
    button: { isCollectionItem: true, optionName: "buttons" },
    CompareRule: { isCollectionItem: true, optionName: "validationRules" },
    CustomRule: { isCollectionItem: true, optionName: "validationRules" },
    EmailRule: { isCollectionItem: true, optionName: "validationRules" },
    format: { isCollectionItem: false, optionName: "format" },
    formItem: { isCollectionItem: false, optionName: "formItem" },
    headerFilter: { isCollectionItem: false, optionName: "headerFilter" },
    lookup: { isCollectionItem: false, optionName: "lookup" },
    NumericRule: { isCollectionItem: true, optionName: "validationRules" },
    PatternRule: { isCollectionItem: true, optionName: "validationRules" },
    RangeRule: { isCollectionItem: true, optionName: "validationRules" },
    RequiredRule: { isCollectionItem: true, optionName: "validationRules" },
    StringLengthRule: { isCollectionItem: true, optionName: "validationRules" },
    validationRule: { isCollectionItem: true, optionName: "validationRules" }
};
var DxCompareRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        comparisonTarget: Function,
        comparisonType: String,
        ignoreEmptyValue: Boolean,
        message: String,
        reevaluate: Boolean,
        type: String
    }
});
exports.DxCompareRule = DxCompareRule;
DxCompareRule.$_optionName = "validationRules";
DxCompareRule.$_isCollectionItem = true;
DxCompareRule.$_predefinedProps = {
    type: "compare"
};
var DxCustomRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        message: String,
        reevaluate: Boolean,
        type: String,
        validationCallback: Function
    }
});
exports.DxCustomRule = DxCustomRule;
DxCustomRule.$_optionName = "validationRules";
DxCustomRule.$_isCollectionItem = true;
DxCustomRule.$_predefinedProps = {
    type: "custom"
};
var DxDependencies = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        dataSource: [Array, Object],
        keyExpr: [Function, String],
        predecessorIdExpr: [Function, String],
        successorIdExpr: [Function, String],
        typeExpr: [Function, String]
    }
});
exports.DxDependencies = DxDependencies;
DxDependencies.$_optionName = "dependencies";
var DxEditing = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        allowDependencyAdding: Boolean,
        allowDependencyDeleting: Boolean,
        allowDependencyUpdating: Boolean,
        allowResourceAdding: Boolean,
        allowResourceDeleting: Boolean,
        allowResourceUpdating: Boolean,
        allowTaskAdding: Boolean,
        allowTaskDeleting: Boolean,
        allowTaskUpdating: Boolean,
        enabled: Boolean
    }
});
exports.DxEditing = DxEditing;
DxEditing.$_optionName = "editing";
var DxEmailRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        message: String,
        type: String
    }
});
exports.DxEmailRule = DxEmailRule;
DxEmailRule.$_optionName = "validationRules";
DxEmailRule.$_isCollectionItem = true;
DxEmailRule.$_predefinedProps = {
    type: "email"
};
var DxFormat = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        currency: String,
        formatter: Function,
        parser: Function,
        precision: Number,
        type: String
    }
});
exports.DxFormat = DxFormat;
DxFormat.$_optionName = "format";
var DxFormItem = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        colSpan: Number,
        cssClass: String,
        dataField: String,
        editorOptions: Object,
        editorType: String,
        helpText: String,
        isRequired: Boolean,
        itemType: String,
        label: Object,
        name: String,
        template: {},
        validationRules: Array,
        visible: Boolean,
        visibleIndex: Number
    }
});
exports.DxFormItem = DxFormItem;
DxFormItem.$_optionName = "formItem";
DxFormItem.$_expectedChildren = {
    AsyncRule: { isCollectionItem: true, optionName: "validationRules" },
    CompareRule: { isCollectionItem: true, optionName: "validationRules" },
    CustomRule: { isCollectionItem: true, optionName: "validationRules" },
    EmailRule: { isCollectionItem: true, optionName: "validationRules" },
    label: { isCollectionItem: false, optionName: "label" },
    NumericRule: { isCollectionItem: true, optionName: "validationRules" },
    PatternRule: { isCollectionItem: true, optionName: "validationRules" },
    RangeRule: { isCollectionItem: true, optionName: "validationRules" },
    RequiredRule: { isCollectionItem: true, optionName: "validationRules" },
    StringLengthRule: { isCollectionItem: true, optionName: "validationRules" },
    validationRule: { isCollectionItem: true, optionName: "validationRules" }
};
var DxHeaderFilter = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        allowSearch: Boolean,
        dataSource: [Array, Object, Function],
        groupInterval: [Number, String],
        height: Number,
        searchMode: String,
        width: Number
    }
});
exports.DxHeaderFilter = DxHeaderFilter;
DxHeaderFilter.$_optionName = "headerFilter";
var DxLabel = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        alignment: String,
        location: String,
        showColon: Boolean,
        text: String,
        visible: Boolean
    }
});
exports.DxLabel = DxLabel;
DxLabel.$_optionName = "label";
var DxLookup = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        allowClearing: Boolean,
        dataSource: [Array, Object, Function],
        displayExpr: [Function, String],
        valueExpr: String
    }
});
exports.DxLookup = DxLookup;
DxLookup.$_optionName = "lookup";
var DxNumericRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        message: String,
        type: String
    }
});
exports.DxNumericRule = DxNumericRule;
DxNumericRule.$_optionName = "validationRules";
DxNumericRule.$_isCollectionItem = true;
DxNumericRule.$_predefinedProps = {
    type: "numeric"
};
var DxPatternRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        message: String,
        pattern: {},
        type: String
    }
});
exports.DxPatternRule = DxPatternRule;
DxPatternRule.$_optionName = "validationRules";
DxPatternRule.$_isCollectionItem = true;
DxPatternRule.$_predefinedProps = {
    type: "pattern"
};
var DxRangeRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        max: {},
        message: String,
        min: {},
        reevaluate: Boolean,
        type: String
    }
});
exports.DxRangeRule = DxRangeRule;
DxRangeRule.$_optionName = "validationRules";
DxRangeRule.$_isCollectionItem = true;
DxRangeRule.$_predefinedProps = {
    type: "range"
};
var DxRequiredRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        message: String,
        trim: Boolean,
        type: String
    }
});
exports.DxRequiredRule = DxRequiredRule;
DxRequiredRule.$_optionName = "validationRules";
DxRequiredRule.$_isCollectionItem = true;
DxRequiredRule.$_predefinedProps = {
    type: "required"
};
var DxResourceAssignments = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        dataSource: [Array, Object],
        keyExpr: [Function, String],
        resourceIdExpr: [Function, String],
        taskIdExpr: [Function, String]
    }
});
exports.DxResourceAssignments = DxResourceAssignments;
DxResourceAssignments.$_optionName = "resourceAssignments";
var DxResources = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        dataSource: [Array, Object],
        keyExpr: [Function, String],
        textExpr: [Function, String]
    }
});
exports.DxResources = DxResources;
DxResources.$_optionName = "resources";
var DxStringLengthRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        ignoreEmptyValue: Boolean,
        max: Number,
        message: String,
        min: Number,
        trim: Boolean,
        type: String
    }
});
exports.DxStringLengthRule = DxStringLengthRule;
DxStringLengthRule.$_optionName = "validationRules";
DxStringLengthRule.$_isCollectionItem = true;
DxStringLengthRule.$_predefinedProps = {
    type: "stringLength"
};
var DxTasks = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        dataSource: [Array, Object],
        endExpr: [Function, String],
        keyExpr: [Function, String],
        parentIdExpr: [Function, String],
        progressExpr: [Function, String],
        startExpr: [Function, String],
        titleExpr: [Function, String]
    }
});
exports.DxTasks = DxTasks;
DxTasks.$_optionName = "tasks";
var DxValidationRule = Vue.extend({
    extends: configuration_component_1.DxConfiguration,
    props: {
        comparisonTarget: Function,
        comparisonType: String,
        ignoreEmptyValue: Boolean,
        max: {},
        message: String,
        min: {},
        pattern: {},
        reevaluate: Boolean,
        trim: Boolean,
        type: String,
        validationCallback: Function
    }
});
exports.DxValidationRule = DxValidationRule;
DxValidationRule.$_optionName = "validationRules";
DxValidationRule.$_isCollectionItem = true;
DxValidationRule.$_predefinedProps = {
    type: "required"
};
exports.default = DxGantt;