devextreme-react 23.1.5 → 23.2.1-alpha-23255-1813

package/esm/core/configuration/comparer.js

@@ -0,0 +1,98 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+import { buildNode, buildTemplates } from './tree';
+import { mergeNameParts } from './utils';
+function compareTemplates(current, prev, changesAccum) {
+    var currentTemplatesOptions = {};
+    var currentTemplates = {};
+    var prevTemplatesOptions = {};
+    var prevTemplates = {};
+    buildTemplates(current, currentTemplatesOptions, currentTemplates);
+    buildTemplates(prev, prevTemplatesOptions, prevTemplates);
+    changesAccum.addRemovedValues(currentTemplatesOptions, prevTemplatesOptions, current.fullName);
+    // TODO: support switching to default templates
+    // appendRemovedValues(currentTemplates, prevTemplates, "", changesAccum.templates);
+    Object.keys(currentTemplatesOptions).forEach(function (key) {
+        if (currentTemplatesOptions[key] === prevTemplatesOptions[key]) {
+            return;
+        }
+        changesAccum.options[mergeNameParts(current.fullName, key)] = currentTemplatesOptions[key];
+    });
+    Object.keys(currentTemplates).forEach(function (key) {
+        var currentTemplate = currentTemplates[key];
+        var prevTemplate = prevTemplates[key];
+        if (prevTemplate && currentTemplate.content === prevTemplate.content) {
+            return;
+        }
+        changesAccum.templates[key] = currentTemplate;
+    });
+}
+function compare(current, prev, changesAccum) {
+    if (!prev) {
+        changesAccum.options[current.fullName] = buildNode(current, changesAccum.templates, true);
+        return;
+    }
+    changesAccum.addRemovedValues(current.options, prev.options, current.fullName);
+    changesAccum.addRemovedValues(current.configCollections, prev.configCollections, current.fullName);
+    changesAccum.addRemovedValues(current.configs, prev.configs, current.fullName);
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    compareCollections(current, prev, changesAccum);
+    Object.keys(current.configs).forEach(function (key) {
+        compare(current.configs[key], prev.configs[key], changesAccum);
+    });
+    Object.keys(current.options).forEach(function (key) {
+        if (current.options[key] === prev.options[key]) {
+            return;
+        }
+        changesAccum.options[mergeNameParts(current.fullName, key)] = current.options[key];
+    });
+    compareTemplates(current, prev, changesAccum);
+}
+function appendRemovedValues(current, prev, path, changesAccum) {
+    var removedKeys = Object.keys(prev).filter(function (key) { return !Object.keys(current).includes(key); });
+    removedKeys.forEach(function (key) {
+        changesAccum.push(mergeNameParts(path, key));
+    });
+}
+function getChanges(current, prev) {
+    var changesAccum = {
+        options: {},
+        removedOptions: [],
+        templates: {},
+        addRemovedValues: function (currentOptions, prevOptions, path) {
+            appendRemovedValues(currentOptions, prevOptions, path, this.removedOptions);
+        },
+    };
+    compare(current, prev, changesAccum);
+    return changesAccum;
+}
+function compareCollections(current, prev, changesAccum) {
+    Object.keys(current.configCollections).forEach(function (key) {
+        var currentCollection = current.configCollections[key];
+        var prevCollection = prev.configCollections[key] || [];
+        if (!currentCollection || currentCollection.length !== prevCollection.length) {
+            var updatedCollection_1 = [];
+            currentCollection.forEach(function (item) {
+                var config = buildNode(item, changesAccum.templates, true);
+                updatedCollection_1.push(config);
+            });
+            changesAccum.options[mergeNameParts(current.fullName, key)] = updatedCollection_1;
+            return;
+        }
+        for (var i = 0; i < currentCollection.length; i += 1) {
+            compare(currentCollection[i], prevCollection[i], changesAccum);
+        }
+    });
+}
+export { getChanges, };

package/esm/core/configuration/config-node.js

@@ -0,0 +1,14 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+export {};

package/esm/core/configuration/react/element.js

@@ -0,0 +1,62 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+import { Template as TemplateComp } from '../../template';
+var ElementType;
+(function (ElementType) {
+    ElementType[ElementType["Option"] = 0] = "Option";
+    ElementType[ElementType["Template"] = 1] = "Template";
+    ElementType[ElementType["Unknown"] = 2] = "Unknown";
+})(ElementType || (ElementType = {}));
+function getElementInfo(element, parentExpectedChildren) {
+    var reactElement = element;
+    if (!reactElement || !reactElement.type) {
+        return {
+            type: ElementType.Unknown,
+        };
+    }
+    if (reactElement.type === TemplateComp) {
+        return {
+            type: ElementType.Template,
+            props: reactElement.props,
+        };
+    }
+    var elementDescriptor = reactElement.type;
+    if (elementDescriptor.OptionName) {
+        var name_1 = elementDescriptor.OptionName;
+        var isCollectionItem = elementDescriptor.IsCollectionItem;
+        var expectation = parentExpectedChildren && parentExpectedChildren[name_1];
+        if (expectation) {
+            isCollectionItem = expectation.isCollectionItem;
+            if (expectation.optionName) {
+                name_1 = expectation.optionName;
+            }
+        }
+        return {
+            type: ElementType.Option,
+            descriptor: {
+                name: name_1,
+                isCollection: isCollectionItem,
+                templates: elementDescriptor.TemplateProps || [],
+                initialValuesProps: elementDescriptor.DefaultsProps || {},
+                predefinedValuesProps: elementDescriptor.PredefinedProps || {},
+                expectedChildren: elementDescriptor.ExpectedChildren || {},
+            },
+            props: reactElement.props,
+        };
+    }
+    return {
+        type: ElementType.Unknown,
+    };
+}
+export { getElementInfo, ElementType, };

package/esm/core/configuration/react/templates.js

@@ -0,0 +1,74 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+function getAnonymousTemplate(props, templateMeta, hasTranscludedContent) {
+    if (templateMeta.tmplOption === 'template' && hasTranscludedContent) {
+        return {
+            optionName: templateMeta.tmplOption,
+            isAnonymous: true,
+            type: 'children',
+            content: props.children,
+            keyFn: props[templateMeta.keyFn],
+        };
+    }
+    if (props[templateMeta.render]) {
+        return {
+            optionName: templateMeta.tmplOption,
+            isAnonymous: true,
+            type: 'render',
+            content: props[templateMeta.render],
+            keyFn: props[templateMeta.keyFn],
+        };
+    }
+    if (props[templateMeta.component]) {
+        return {
+            optionName: templateMeta.tmplOption,
+            isAnonymous: true,
+            type: 'component',
+            content: props[templateMeta.component],
+            keyFn: props[templateMeta.keyFn],
+        };
+    }
+    return null;
+}
+function getNamedTemplate(props) {
+    if (!props.name) {
+        return null;
+    }
+    if (props.component) {
+        return {
+            optionName: props.name,
+            isAnonymous: false,
+            type: 'component',
+            content: props.component,
+            keyFn: props.keyFn,
+        };
+    }
+    if (props.render) {
+        return {
+            optionName: props.name,
+            isAnonymous: false,
+            type: 'render',
+            content: props.render,
+            keyFn: props.keyFn,
+        };
+    }
+    return {
+        optionName: props.name,
+        isAnonymous: false,
+        type: 'children',
+        content: props.children,
+        keyFn: props.keyFn,
+    };
+}
+export { getAnonymousTemplate, getNamedTemplate, };

package/esm/core/configuration/react/tree.js

@@ -0,0 +1,101 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import * as React from 'react';
+import { separateProps } from '../../widget-config';
+import { ElementType, getElementInfo, } from './element';
+import { mergeNameParts } from '../utils';
+import { getAnonymousTemplate, getNamedTemplate } from './templates';
+export function processChildren(parentElement, parentFullName) {
+    var templates = [];
+    var configCollections = {};
+    var configs = {};
+    var hasTranscludedContent = false;
+    React.Children.map(parentElement.props.children, function (child) {
+        var element = getElementInfo(child, parentElement.descriptor.expectedChildren);
+        if (element.type === ElementType.Unknown) {
+            if (child !== null && child !== undefined && child !== false) {
+                hasTranscludedContent = true;
+            }
+            return;
+        }
+        if (element.type === ElementType.Template) {
+            var template = getNamedTemplate(element.props);
+            if (template) {
+                templates.push(template);
+            }
+            return;
+        }
+        if (element.descriptor.isCollection) {
+            var collection = configCollections[element.descriptor.name];
+            if (!collection) {
+                collection = [];
+                configCollections[element.descriptor.name] = collection;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            var collectionItem = createConfigNode(element, mergeNameParts(parentFullName, element.descriptor.name) + "[" + collection.length + "]");
+            collection.push(collectionItem);
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        var configNode = createConfigNode(element, parentFullName);
+        configs[element.descriptor.name] = configNode;
+    });
+    return {
+        configs: configs,
+        configCollections: configCollections,
+        templates: templates,
+        hasTranscludedContent: hasTranscludedContent,
+    };
+}
+function createConfigNode(element, path) {
+    var fullName = element.descriptor.isCollection
+        ? path
+        : mergeNameParts(path, element.descriptor.name);
+    var separatedValues = separateProps(element.props, element.descriptor.initialValuesProps, element.descriptor.templates);
+    var childrenData = processChildren(element, fullName);
+    element.descriptor.templates.forEach(function (templateMeta) {
+        var template = getAnonymousTemplate(element.props, templateMeta, path.length > 0 ? childrenData.hasTranscludedContent : false);
+        if (template) {
+            childrenData.templates.push(template);
+        }
+    });
+    return {
+        fullName: fullName,
+        predefinedOptions: element.descriptor.predefinedValuesProps,
+        initialOptions: separatedValues.defaults,
+        options: separatedValues.options,
+        templates: childrenData.templates,
+        configCollections: childrenData.configCollections,
+        configs: childrenData.configs,
+    };
+}
+function buildConfigTree(widgetDescriptor, props) {
+    return createConfigNode({
+        type: ElementType.Option,
+        descriptor: __assign({ name: '', isCollection: false }, widgetDescriptor),
+        props: props,
+    }, '');
+}
+export { buildConfigTree, };

package/esm/core/configuration/tree.js

@@ -0,0 +1,118 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+import { mergeNameParts, parseOptionName } from './utils';
+function buildTemplates(node, optionsAccum, templatesAccum) {
+    node.templates.forEach(function (template) {
+        if (template.isAnonymous) {
+            var templateName = mergeNameParts(node.fullName, template.optionName);
+            optionsAccum[template.optionName] = templateName;
+            templatesAccum[templateName] = template;
+        }
+        else {
+            templatesAccum[template.optionName] = template;
+        }
+    });
+}
+function buildNode(node, templatesAccum, ignoreInitialValues) {
+    var result = {};
+    Object.keys(node.predefinedOptions).forEach(function (key) {
+        result[key] = node.predefinedOptions[key];
+    });
+    Object.keys(node.configs).forEach(function (key) {
+        result[key] = buildNode(node.configs[key], templatesAccum, ignoreInitialValues);
+    });
+    Object.keys(node.configCollections).forEach(function (key) {
+        result[key] = node.configCollections[key].map(function (item) { return buildNode(item, templatesAccum, ignoreInitialValues); });
+    });
+    if (!ignoreInitialValues) {
+        Object.keys(node.initialOptions).forEach(function (key) {
+            result[key] = node.initialOptions[key];
+        });
+    }
+    Object.keys(node.options).forEach(function (key) {
+        result[key] = node.options[key];
+    });
+    buildTemplates(node, result, templatesAccum);
+    return result;
+}
+function buildConfig(root, ignoreInitialValues) {
+    var templatesAccum = {};
+    var options = buildNode(root, templatesAccum, ignoreInitialValues);
+    return {
+        templates: templatesAccum,
+        options: options,
+    };
+}
+var ValueType;
+(function (ValueType) {
+    ValueType[ValueType["Simple"] = 0] = "Simple";
+    ValueType[ValueType["Complex"] = 1] = "Complex";
+    ValueType[ValueType["Array"] = 2] = "Array";
+})(ValueType || (ValueType = {}));
+function findValueInObject(obj, path) {
+    var key = path.shift();
+    if (!key) {
+        return {
+            value: obj,
+            type: ValueType.Simple,
+        };
+    }
+    if (obj instanceof Object && Object.keys(obj).includes(key)) {
+        return findValueInObject(obj[key], path);
+    }
+    return undefined;
+}
+function findValue(node, path) {
+    var name = path.shift();
+    if (!name) {
+        return {
+            value: buildConfig(node, true).options,
+            type: ValueType.Complex,
+        };
+    }
+    var optionInfo = parseOptionName(name);
+    if (optionInfo.name in node.options) {
+        var options = optionInfo.isCollectionItem
+            ? node.options[optionInfo.name][optionInfo.index]
+            : node.options[optionInfo.name];
+        return findValueInObject(options, path);
+    }
+    if (optionInfo.isCollectionItem) {
+        var collection = node.configCollections[optionInfo.name];
+        if (!collection) {
+            return undefined;
+        }
+        var item = collection[optionInfo.index];
+        if (!item) {
+            return undefined;
+        }
+        return findValue(item, path);
+    }
+    var child = node.configs[optionInfo.name];
+    if (child) {
+        return findValue(child, path);
+    }
+    var childCollection = node.configCollections[optionInfo.name];
+    if (childCollection) {
+        if (path.length !== 0) {
+            return undefined;
+        }
+        return {
+            value: childCollection.map(function (item) { return buildNode(item, {}, true); }),
+            type: ValueType.Array,
+        };
+    }
+    return undefined;
+}
+export { ValueType, buildConfig, buildNode, buildTemplates, findValue, findValueInObject, };

package/esm/core/configuration/utils.js

@@ -0,0 +1,47 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+export function mergeNameParts() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return args.filter(function (value) { return value; }).join('.');
+}
+export function parseOptionName(name) {
+    var parts = name.split('[');
+    if (parts.length === 1) {
+        return {
+            isCollectionItem: false,
+            name: name,
+        };
+    }
+    return {
+        isCollectionItem: true,
+        name: parts[0],
+        index: Number(parts[1].slice(0, -1)),
+    };
+}
+export var isIE = function () {
+    var _a, _b;
+    var ua = (_b = (_a = window === null || window === void 0 ? void 0 : window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) !== null && _b !== void 0 ? _b : ''; // Check the userAgent property of the window.navigator object
+    var msie = ua.indexOf('MSIE'); // IE 10 or older
+    var trident = ua.indexOf('Trident/'); // IE 11
+    return msie > 0 || trident > 0;
+};
+export var shallowEquals = function (first, second) {
+    if (Object.keys(first).length !== Object.keys(second).length) {
+        return false;
+    }
+    return Object.keys(first).every(function (key) { return first[key] === second[key]; });
+};

package/{core → esm/core}/dx-template.js

@@ -1,7 +1,7 @@
 /*!
  * devextreme-react
- * Version: 23.1.5
- * Build date: Wed Aug 30 2023
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
  *
  * Copyright (c) 2012 - 2023 Developer Express Inc. ALL RIGHTS RESERVED
  *
@@ -11,19 +11,16 @@
  * https://github.com/DevExpress/devextreme-react
  */
 
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDxTemplate = void 0;
-var React = require("react");
-var events = require("devextreme/events");
-var helpers_1 = require("./helpers");
-var template_wrapper_1 = require("./template-wrapper");
-var component_base_1 = require("./component-base");
+import * as React from 'react';
+import * as events from 'devextreme/events';
+import { DoubleKeyMap, generateID } from './helpers';
+import { TemplateWrapper } from './template-wrapper';
+import { DX_REMOVE_EVENT } from './component-base';
 function unwrapElement(element) {
     return element.get ? element.get(0) : element;
 }
 function createDxTemplate(createContentProvider, templatesStore, keyFn) {
-    var renderedTemplates = new helpers_1.DoubleKeyMap();
+    var renderedTemplates = new DoubleKeyMap();
     return {
         render: function (data) {
             var container = unwrapElement(data.container);
@@ -36,19 +33,19 @@ function createDxTemplate(createContentProvider, templatesStore, keyFn) {
             };
             var _subscribeOnContainerRemoval = function () {
                 if (container.nodeType === Node.ELEMENT_NODE) {
-                    events.one(container, component_base_1.DX_REMOVE_EVENT, onRemoved);
+                    events.one(container, DX_REMOVE_EVENT, onRemoved);
                 }
             };
             var _unsubscribeOnContainerRemoval = function () {
                 if (container.nodeType === Node.ELEMENT_NODE) {
-                    events.off(container, component_base_1.DX_REMOVE_EVENT, onRemoved);
+                    events.off(container, DX_REMOVE_EVENT, onRemoved);
                 }
             };
             if (prevTemplateId) {
                 templateId = prevTemplateId;
             }
             else {
-                templateId = keyFn ? keyFn(data.model) : "__template_" + helpers_1.generateID();
+                templateId = keyFn ? keyFn(data.model) : "__template_" + generateID();
                 if (data.model !== undefined) {
                     renderedTemplates.set(key, templateId);
                 }
@@ -60,7 +57,7 @@ function createDxTemplate(createContentProvider, templatesStore, keyFn) {
                     index: data.index,
                 };
                 var contentProvider = createContentProvider();
-                return React.createElement(template_wrapper_1.TemplateWrapper, {
+                return React.createElement(TemplateWrapper, {
                     content: contentProvider(props),
                     container: container,
                     onRemoved: onRemoved,
@@ -77,4 +74,4 @@ function createDxTemplate(createContentProvider, templatesStore, keyFn) {
         },
     };
 }
-exports.createDxTemplate = createDxTemplate;
+export { createDxTemplate, };

package/esm/core/extension-component.js

@@ -0,0 +1,46 @@
+/*!
+ * devextreme-react
+ * Version: 23.2.1-alpha-23255-1813
+ * Build date: Tue Sep 12 2023
+ *
+ * Copyright (c) 2012 - 2023 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-react
+ */
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ComponentBase } from './component-base';
+var ExtensionComponent = /** @class */ (function (_super) {
+    __extends(ExtensionComponent, _super);
+    function ExtensionComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ExtensionComponent.prototype.componentDidMount = function () {
+        var onMounted = this.props.onMounted;
+        if (onMounted) {
+            onMounted(this._createWidget);
+        }
+        else {
+            this._createWidget();
+        }
+    };
+    return ExtensionComponent;
+}(ComponentBase));
+export { ExtensionComponent, };