@atlaskit/editor-core 151.1.2 → 151.3.1

package/dist/es2019/ui/ConfigPanel/ConfigPanel.js

@@ -6,11 +6,12 @@ import { withAnalyticsContext, withAnalyticsEvents } from '@atlaskit/analytics-n
 import Form from '@atlaskit/form';
 import { isTabGroup } from '@atlaskit/editor-common/extensions';
 import _isEqual from 'lodash/isEqual';
+import _mergeRecursive from 'lodash/merge';
 import { fireAnalyticsEvent, EVENT_TYPE, ACTION_SUBJECT, ACTION } from '../../plugins/analytics';
 import LoadingState from './LoadingState';
 import Header from './Header';
 import ErrorMessage from './ErrorMessage';
-import { serialize, deserialize } from './transformers';
+import { serialize, deserialize, findDuplicateFields } from './transformers';
 import { injectIntl } from 'react-intl';
 import ButtonGroup from '@atlaskit/button/button-group';
 import Button from '@atlaskit/button/custom-theme-button';
@@ -19,6 +20,7 @@ import { pluginKey as extensionPluginKey } from '../../plugins/extension/plugin-
 import WithPluginState from '../WithPluginState';
 import FormContent from './FormContent';
 import { messages } from './messages';
+import { FormErrorBoundary } from './FormErrorBoundary';
 
 function ConfigForm({
   canSave,
@@ -32,8 +34,19 @@ function ConfigForm({
   onCancel,
   onFieldChange,
   parameters,
-  submitting
+  submitting,
+  contextIdentifierProvider
 }) {
+  useEffect(() => {
+    if (fields) {
+      const firstDuplicateField = findDuplicateFields(fields);
+
+      if (firstDuplicateField) {
+        throw new Error(`Possible duplicate field name: \`${firstDuplicateField.name}\`.`);
+      }
+    }
+  }, [fields]);
+
   if (isLoading || !hasParsedParameters && errorMessage === null) {
     return /*#__PURE__*/React.createElement(LoadingState, null);
   }
@@ -44,34 +57,27 @@ function ConfigForm({
     });
   }
 
-  return /*#__PURE__*/React.createElement(WithPluginState, {
-    plugins: {
-      extension: extensionPluginKey
-    },
-    render: ({
-      extension
-    }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FormContent, {
-      fields: fields,
-      parameters: parameters,
-      extensionManifest: extensionManifest,
-      onFieldChange: onFieldChange,
-      firstVisibleFieldName: firstVisibleFieldName,
-      contextIdentifierProvider: extension === null || extension === void 0 ? void 0 : extension.contextIdentifierProvider
-    }), /*#__PURE__*/React.createElement("div", {
-      style: canSave ? {} : {
-        display: 'none'
-      }
-    }, /*#__PURE__*/React.createElement(FormFooter, {
-      align: "start"
-    }, /*#__PURE__*/React.createElement(ButtonGroup, null, /*#__PURE__*/React.createElement(Button, {
-      type: "submit",
-      appearance: "primary"
-    }, intl.formatMessage(messages.submit)), /*#__PURE__*/React.createElement(Button, {
-      appearance: "default",
-      isDisabled: submitting,
-      onClick: onCancel
-    }, intl.formatMessage(messages.cancel))))))
-  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FormContent, {
+    fields: fields,
+    parameters: parameters,
+    extensionManifest: extensionManifest,
+    onFieldChange: onFieldChange,
+    firstVisibleFieldName: firstVisibleFieldName,
+    contextIdentifierProvider: contextIdentifierProvider
+  }), /*#__PURE__*/React.createElement("div", {
+    style: canSave ? {} : {
+      display: 'none'
+    }
+  }, /*#__PURE__*/React.createElement(FormFooter, {
+    align: "start"
+  }, /*#__PURE__*/React.createElement(ButtonGroup, null, /*#__PURE__*/React.createElement(Button, {
+    type: "submit",
+    appearance: "primary"
+  }, intl.formatMessage(messages.submit)), /*#__PURE__*/React.createElement(Button, {
+    appearance: "default",
+    isDisabled: submitting,
+    onClick: onCancel
+  }, intl.formatMessage(messages.cancel))))));
 }
 
 const ConfigFormIntl = injectIntl(ConfigForm);
@@ -126,14 +132,48 @@ class ConfigPanel extends React.Component {
     });
 
     _defineProperty(this, "backfillTabFormData", (fields, formData, currentParameters) => {
-      const mergedTabGroups = fields.filter(isTabGroup).reduce((acc, field) => ({ ...acc,
-        [field.name]: { ...(currentParameters[field.name] || {}),
-          ...(formData[field.name] || {})
+      const getRelevantData = (field, formParams, currentParams, backfill) => {
+        if (field.hasGroupedValues && !(field.name in backfill)) {
+          backfill[field.name] = {};
         }
-      }), {});
-      return { ...formData,
-        ...mergedTabGroups
-      };
+
+        const actualFormParams = field.hasGroupedValues ? formParams[field.name] || {} : formParams;
+        const actualCurrentParams = field.hasGroupedValues ? currentParams[field.name] || {} : currentParams;
+        const actualBackfillParams = field.hasGroupedValues ? backfill[field.name] : backfill;
+        return {
+          formParams: actualFormParams,
+          currentParams: actualCurrentParams,
+          backfillParams: actualBackfillParams
+        };
+      }; // Traverse any tab structures and backfill field values on tabs
+      // which aren't shown. This filter should be ok because tabs are
+      // currently only allowed on top level
+
+
+      const mergedTabGroups = fields.filter(isTabGroup).reduce((missingBackfill, tabGroup) => {
+        const {
+          formParams: tabGroupFormData,
+          currentParams: tabGroupCurrentData,
+          backfillParams: tabGroupParams
+        } = getRelevantData(tabGroup, formData, currentParameters, missingBackfill); // Loop through tabs and see what fields are missing from current data
+
+        tabGroup.fields.forEach(tabField => {
+          const {
+            formParams: tabFormData,
+            currentParams: tabCurrentData,
+            backfillParams: tabParams
+          } = getRelevantData(tabField, tabGroupFormData, tabGroupCurrentData, tabGroupParams);
+          tabField.fields.forEach(field => {
+            if (field.name in tabFormData || !(field.name in tabCurrentData)) {
+              return;
+            }
+
+            tabParams[field.name] = tabCurrentData[field.name];
+          });
+        });
+        return missingBackfill;
+      }, {});
+      return _mergeRecursive({}, mergedTabGroups, formData);
     });
 
     _defineProperty(this, "handleSubmit", async formData => {
@@ -352,18 +392,30 @@ class ConfigPanel extends React.Component {
           noValidate: true,
           onKeyDown: handleKeyDown,
           "data-testid": "extension-config-panel"
-        }), this.renderHeader(extensionManifest), /*#__PURE__*/React.createElement(ConfigFormIntl, {
-          canSave: !autoSave,
-          errorMessage: errorMessage,
-          extensionManifest: extensionManifest,
-          fields: fields,
-          firstVisibleFieldName: firstVisibleFieldName,
-          hasParsedParameters: hasParsedParameters,
-          isLoading: isLoading || false,
-          onCancel: onCancel,
-          onFieldChange: onFieldChange,
-          parameters: currentParameters,
-          submitting: submitting
+        }), this.renderHeader(extensionManifest), /*#__PURE__*/React.createElement(WithPluginState, {
+          plugins: {
+            extension: extensionPluginKey
+          },
+          render: ({
+            extension
+          }) => /*#__PURE__*/React.createElement(FormErrorBoundary, {
+            contextIdentifierProvider: extension === null || extension === void 0 ? void 0 : extension.contextIdentifierProvider,
+            extensionKey: extensionManifest.key,
+            fields: fields || []
+          }, /*#__PURE__*/React.createElement(ConfigFormIntl, {
+            canSave: !autoSave,
+            errorMessage: errorMessage,
+            extensionManifest: extensionManifest,
+            fields: fields,
+            firstVisibleFieldName: firstVisibleFieldName,
+            hasParsedParameters: hasParsedParameters,
+            isLoading: isLoading || false,
+            onCancel: onCancel,
+            onFieldChange: onFieldChange,
+            parameters: currentParameters,
+            submitting: submitting,
+            contextIdentifierProvider: extension === null || extension === void 0 ? void 0 : extension.contextIdentifierProvider
+          }))
         }));
       });
     });

package/dist/es2019/ui/ConfigPanel/FormContent.js

@@ -134,35 +134,44 @@ export function FieldComponent({
       });
 
     case 'expand':
-      // if expand is under a tab.
-      const resolvedParentName = parentName ? `${parentName}.${field.name}` : field.name;
-      return /*#__PURE__*/React.createElement(Expand, {
-        field: field,
-        isExpanded: field.isExpanded
-      }, /*#__PURE__*/React.createElement(FormContent, {
-        parentName: resolvedParentName,
-        fields: field.fields,
-        parameters: parameters[field.name] || {},
-        onFieldChange: onFieldChange,
-        extensionManifest: extensionManifest
-      }));
-
-    case 'tab-group':
-      const renderPanel = tabField => {
-        const tabParameters = parameters[field.name] || {};
-        return /*#__PURE__*/React.createElement(FormContent, {
-          parentName: `${field.name}.${tabField.name}`,
-          fields: tabField.fields,
-          parameters: tabParameters[tabField.name] || {},
+      {
+        // if expand is under a tab with hasGroupedValues=true
+        const resolvedParentName = [parentName, field.hasGroupedValues ? field.name : undefined].filter(val => !!val).join('.') || undefined;
+        const resolvedParameters = !field.hasGroupedValues ? parameters : parameters[field.name] || {};
+        return /*#__PURE__*/React.createElement(Expand, {
+          field: field,
+          isExpanded: field.isExpanded
+        }, /*#__PURE__*/React.createElement(FormContent, {
+          parentName: resolvedParentName,
+          fields: field.fields,
+          parameters: resolvedParameters,
           onFieldChange: onFieldChange,
           extensionManifest: extensionManifest
-        });
-      };
+        }));
+      }
 
-      return /*#__PURE__*/React.createElement(TabGroup, {
-        field: field,
-        renderPanel: renderPanel
-      });
+    case 'tab-group':
+      {
+        const tabGroupField = field;
+        const tabGroupParams = tabGroupField.hasGroupedValues ? parameters[tabGroupField.name] || {} : parameters;
+
+        const renderPanel = tabField => {
+          const parentName = [tabGroupField.hasGroupedValues ? tabGroupField.name : undefined, tabField.hasGroupedValues ? tabField.name : undefined].filter(val => !!val).join('.') || undefined;
+          const tabParameters = tabField.hasGroupedValues ? tabGroupParams[tabField.name] || {} : tabGroupParams;
+          return /*#__PURE__*/React.createElement(FormContent, {
+            parentName: parentName,
+            fields: tabField.fields,
+            parameters: tabParameters,
+            onFieldChange: onFieldChange,
+            extensionManifest: extensionManifest
+          });
+        };
+
+        return /*#__PURE__*/React.createElement(TabGroup, {
+          field: tabGroupField,
+          renderPanel: renderPanel
+        });
+      }
 
     default:
       return /*#__PURE__*/React.createElement(UnhandledType, {

package/dist/es2019/ui/ConfigPanel/transformers.js

@@ -1,4 +1,4 @@
-import { isFieldset, isDateRange, isTabGroup, isExpand, getFieldSerializer, getFieldDeserializer } from '@atlaskit/editor-common/extensions';
+import { isFieldset, isDateRange, isTabGroup, isTabField, isExpand, getFieldSerializer, getFieldDeserializer } from '@atlaskit/editor-common/extensions';
 import { getNameFromDuplicateField, isDuplicateField } from './utils';
 
 const isOption = option => {
@@ -8,10 +8,9 @@ const isOption = option => {
 const isOptions = options => {
   return Array.isArray(options) && options.every(isOption);
 };
-/** maps the typed-values from the Form values object */
-
 
-function extract(value, field) {
+/** maps the typed-values from the Form values object */
+function extract(value, field, options) {
   if (isOptions(value)) {
     return value.map(item => item.value);
   } else if (isOption(value)) {
@@ -24,79 +23,235 @@ function extract(value, field) {
     }
 
     return Number(value);
+  } // Workaround for https://product-fabric.atlassian.net/browse/DST-2701
+  else if (options !== null && options !== void 0 && options.useDefaultValue && value === undefined && 'defaultValue' in field) {
+    return field.defaultValue;
   }
 
   return value;
 }
 
-export const serialize = async (manifest, data, fields, depth = 0) => {
+export const findDuplicateFields = fields => findDuplicateFieldsInternal(flattenFields(fields));
+
+const findDuplicateFieldsInternal = fields => {
+  const allowDuplicatesMap = {};
+  return fields.find(field => {
+    if (isExpand(field)) {
+      return findDuplicateFieldsInternal(field.fields);
+    } else if (isTabGroup(field)) {
+      return field.fields.find(tabField => findDuplicateFieldsInternal(tabField.fields));
+    } else if (allowDuplicatesMap[field.name] === undefined) {
+      allowDuplicatesMap[field.name] = !!field.allowDuplicates;
+      return;
+    } else if (!field.allowDuplicates || !allowDuplicatesMap[field.name]) {
+      return field;
+    }
+
+    return;
+  });
+};
+
+export const serialize = async (manifest, data, fields, options = {}) => {
   const result = [];
+  const {
+    depth = 0,
+    parentType
+  } = options;
+  const flattenedFields = flattenFields(fields);
+  const fillResults = flattenedFields.map(async field => {
+    if (isTabGroup(field)) {
+      const tabGroupData = await serializeTabGroupField(manifest, field, data);
+      result.push(...tabGroupData);
+    } else if (isTabField(field)) {
+      const tabData = await serializeTabField(manifest, field, data);
+      result.push(...tabData);
+    } else if (isExpand(field)) {
+      const expandData = await serializeExpandField(manifest, field, data);
+      result.push(...expandData);
+    } // WARNING: don't recursively serialize, limit to depth < 1
+    // serializable?
+    else if (isFieldset(field) && depth === 0) {
+      const fieldsetData = await serializeFieldset(manifest, field, data, depth);
 
-  if (data) {
-    for (const name in data) {
-      const field = fields.find(field => field.name === getNameFromDuplicateField(name));
+      if (fieldsetData) {
+        result.push(fieldsetData);
+      }
+    } else {
+      const value = extract(data[field.name], field, {
+        useDefaultValue: true
+      }); // ignore undefined values
+
+      if (value !== undefined) {
+        result.push({
+          [field.name]: value
+        });
+      }
+    }
+  });
+  await Promise.all(fillResults); // Crunch fields down to parameters
 
-      if (field === undefined) {
-        continue;
-      } // ignore undefined values
+  const parameters = result.reduce((obj, current) => {
+    for (const key in current) {
+      obj[key] = current[key];
+    }
 
+    return obj;
+  }, {}); // Fix up duplicate values (currently only for fieldsets)
 
-      let value = extract(data[name], field);
+  const hasDuplicateFields = parentType === 'fieldset' && !!flattenedFields.find(field => field.allowDuplicates);
 
-      if (value === undefined) {
-        continue;
-      }
+  if (hasDuplicateFields) {
+    return serializeMergeDuplicateFieldData(parameters, data, flattenedFields);
+  }
 
-      if (isTabGroup(field)) {
-        const {
-          fields: tabs
-        } = field;
-        value = {};
+  return parameters;
+};
 
-        const resolveTabValues = async (tabField, groupData) => {
-          return await serialize(manifest, groupData[tabField.name] || {}, tabField.fields);
-        };
+const serializeFieldset = async (manifest, field, data, depth) => {
+  let fieldSerializer;
 
-        for (let i = 0; i < tabs.length; i++) {
-          const tabField = tabs[i];
-          value[tabField.name] = await resolveTabValues(tabField, data[field.name] || {});
-        }
-      } else if (isExpand(field)) {
-        value = await serialize(manifest, data[field.name] || {}, field.fields);
-      } // WARNING: don't recursively serialize, limit to depth < 1
-      // serializable?
-      else if (isFieldset(field) && depth === 0) {
-        const fieldSerializer = await getFieldSerializer(manifest, field.options.transformer);
-
-        if (fieldSerializer) {
-          const {
-            fields: fieldsetFields
-          } = field;
-          const extracted = await serialize(manifest, value, fieldsetFields, depth + 1);
-          value = fieldSerializer(extracted);
-        }
+  try {
+    fieldSerializer = await getFieldSerializer(manifest, field.options.transformer);
+  } catch (ex) {
+    // We only throw if there is data that may be lost
+    if (data[field.name] !== undefined) {
+      throw ex;
+    }
+  }
+
+  if (!fieldSerializer) {
+    return;
+  }
+
+  const {
+    fields: fieldsetFields
+  } = field;
+  const fieldParams = extract(data[field.name], field, {
+    useDefaultValue: true
+  }) || {};
+  const extracted = await serialize(manifest, fieldParams, fieldsetFields, {
+    depth: depth + 1,
+    parentType: 'fieldset'
+  });
+  return {
+    [field.name]: fieldSerializer(extracted)
+  };
+};
+
+const serializeExpandField = async (manifest, field, data) => {
+  const expandData = field.hasGroupedValues ? data[field.name] || {} : data;
+  const value = await serialize(manifest, expandData, field.fields, {
+    parentType: 'expand'
+  });
+  const results = [];
+
+  if (!field.hasGroupedValues) {
+    for (const fieldName in value) {
+      results.push({
+        [fieldName]: value[fieldName]
+      });
+    }
+  } else {
+    results.push({
+      [field.name]: value
+    });
+  }
+
+  return results;
+};
+
+const resolveTabValues = async (manifest, tabField, groupData) => {
+  const tabFieldParams = tabField.hasGroupedValues ? groupData[tabField.name] || {} : groupData;
+  return await serialize(manifest, tabFieldParams, tabField.fields, {
+    parentType: 'tab'
+  });
+};
+
+const serializeTabGroupField = async (manifest, field, data) => {
+  const {
+    fields: tabs
+  } = field;
+  const results = [];
+  const value = {};
+
+  for (let i = 0; i < tabs.length; i++) {
+    const tabField = tabs[i];
+    const tabFieldParameters = await resolveTabValues(manifest, tabField, field.hasGroupedValues ? data[field.name] || {} : data);
+
+    if (tabField.hasGroupedValues) {
+      // Keep namespaced by tab
+      value[tabField.name] = tabFieldParameters;
+    } else {
+      // Copy into tabGroup value
+      for (const fieldName in tabFieldParameters) {
+        value[fieldName] = tabFieldParameters[fieldName];
       }
+    }
+  } // Now for tabGroup...
+
 
-      result.push({
-        [field.name]: value
+  if (field.hasGroupedValues) {
+    results.push({
+      [field.name]: value
+    });
+  } else {
+    for (const fieldName in value) {
+      results.push({
+        [fieldName]: value
       });
     }
-  } // when there are duplicate fields we return an array eg. [{ title: 'one' }, { title: 'two' }]
-  // when there aren't we return an object eg. { title: 'one' }
+  }
 
+  return results;
+};
 
-  const hasDuplicateFields = !!Object.keys(data).find(key => isDuplicateField(key));
+const serializeTabField = async (manifest, field, data) => {
+  const results = [];
+  const tabField = field;
+  const tabFieldParameters = await resolveTabValues(manifest, tabField, data);
 
-  if (hasDuplicateFields) {
-    return result;
+  if (tabField.hasGroupedValues) {
+    // Keep namespaced by tab
+    results.push({
+      [tabField.name]: tabFieldParameters
+    });
+  } else {
+    // Copy into tabGroup value
+    for (const fieldName in tabFieldParameters) {
+      results.push({
+        [fieldName]: tabFieldParameters[fieldName]
+      });
+    }
   }
 
-  return result.reduce((obj, current) => {
-    for (const key in current) {
-      obj[key] = current[key];
+  return results;
+};
+
+const serializeMergeDuplicateFieldData = (parameters, formData, flattenedFields) => {
+  // Weed out all the non-duplicate field names
+  const allDuplicateFieldNames = Object.keys(formData).filter(key => isDuplicateField(key));
+  return flattenedFields.reduce((newParams, field) => {
+    const paramValue = parameters[field.name];
+
+    if (!field.allowDuplicates && paramValue !== undefined) {
+      newParams[field.name] = paramValue;
+    } else {
+      // extract the given duplicate values through the field
+      const duplicateValues = allDuplicateFieldNames.filter(name => getNameFromDuplicateField(name) === field.name).map(duplicateFieldName => extract(formData[duplicateFieldName], field, {
+        useDefaultValue: true
+      })); // Merge and ensure that all values are worth serializing
+
+      const mergedValues = [paramValue, // first value
+      ...duplicateValues].filter(value => value !== undefined);
+
+      if (mergedValues.length > 0) {
+        // Replace so the duplicate field values are saved under the
+        // fieldName as an array
+        newParams[field.name] = mergedValues;
+      }
     }
 
-    return obj;
+    return newParams;
   }, {});
 };
 
@@ -137,21 +292,51 @@ function injectDefaultValues(data, fields) {
     }
   }
 
-  if (doParametersContainDuplicateFields(copy)) {
-    return copy;
-  }
-
   return convertToParametersObject(copy);
 }
+/**
+ * Flattens the given FieldDefinition[] so it resembles the expected data
+ * structure in result Parameters.
+ */
+
+
+const flattenFields = fields => {
+  const flattenAccumulator = (accumulator, field) => {
+    if (isTabGroup(field)) {
+      if (field.hasGroupedValues) {
+        accumulator.push(field);
+      } else {
+        const flattenedTabs = field.fields.reduce((tabAccumulator, tab) => {
+          return tabAccumulator.concat(tab.hasGroupedValues ? tab : tab.fields.reduce(flattenAccumulator, []));
+        }, []);
+        accumulator.push(...flattenedTabs);
+      }
+    } else if (isExpand(field)) {
+      if (field.hasGroupedValues) {
+        accumulator.push(field);
+      } else {
+        const flattenedExpand = field.fields.reduce(flattenAccumulator, []);
+        accumulator.push(...flattenedExpand);
+      }
+    } else {
+      accumulator.push(field);
+    }
+
+    return accumulator;
+  };
+
+  return fields.reduce(flattenAccumulator, []);
+};
 
 export const deserialize = async (manifest, data, fields, depth = 0) => {
   const dataArray = convertToParametersArray(data);
   let result = [];
   const errors = [];
+  const flattenedFields = flattenFields(fields);
 
   for (const item of dataArray) {
     const [name, originalValue] = Object.entries(item)[0];
-    const field = fields.find(field => field.name === getNameFromDuplicateField(name));
+    const field = flattenedFields.find(field => field.name === getNameFromDuplicateField(name));
 
     if (field === undefined) {
       continue;
@@ -193,21 +378,7 @@ export const deserialize = async (manifest, data, fields, depth = 0) => {
     result.errors = convertToParametersObject(errors);
   }
 
-  return injectDefaultValues(result, fields);
-};
-
-const doParametersContainDuplicateFields = parameters => {
-  const keyMap = new Set();
-
-  for (const param of parameters) {
-    const key = Object.keys(param)[0];
-
-    if (keyMap.has(key)) {
-      return true;
-    }
-
-    keyMap.add(key);
-  }
+  return injectDefaultValues(result, flattenedFields);
 };
 
 const convertToParametersObject = (parameters = []) => {

package/dist/es2019/ui/ConfigPanel/utils.js

@@ -8,7 +8,6 @@ export const fromEntries = iterable => {
     return obj;
   }, {});
 };
-export const toEntries = parameters => Array.isArray(parameters) ? parameters.reduce((prev, curr) => [...prev, ...Object.entries(curr)], []) : Object.entries(parameters);
 
 const isEmptyString = value => typeof value === 'string' && value === '';
 
@@ -50,7 +49,7 @@ export const getSafeParentedName = (name, parentName) => {
 const duplicateFieldRegex = /:[0-9]+$/;
 export const isDuplicateField = key => duplicateFieldRegex.test(key);
 export const getNameFromDuplicateField = key => key.replace(duplicateFieldRegex, '');
-/* 
+/*
     ColorPickerButton only accepts 8 digit hex alpha values, for example:
     #123fffaa (8 digits, hex alpha)
     */

package/dist/es2019/ui/Dropdown/index.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import React from 'react';
-import { PureComponent } from 'react';
+import { PureComponent } from 'react'; // eslint-disable-next-line @atlaskit/design-system/no-deprecated-imports
+
 import DropdownList from '@atlaskit/droplist';
 import { Popup } from '@atlaskit/editor-common';
 import withOuterListeners from '../with-outer-listeners';