@limetech/lime-elements 39.13.2 → 39.14.0

package/dist/collection/components/form/templates/array-field-item.js

@@ -0,0 +1,47 @@
+import React, { useContext } from "react";
+import { isObjectType } from "../schema";
+import { CollapsibleItemTemplate } from "./array-field-collapsible-item";
+import { SimpleItemTemplate } from "./array-field-simple-item";
+import { ArrayFieldContext } from "./array-context";
+export const ArrayFieldItemTemplate = (props) => {
+    const arrayContext = useContext(ArrayFieldContext);
+    const schema = arrayContext === null || arrayContext === void 0 ? void 0 : arrayContext.arraySchema;
+    const formData = arrayContext === null || arrayContext === void 0 ? void 0 : arrayContext.formData;
+    const formContext = props.registry.formContext;
+    const allowItemReorder = canItemReorder(props, schema);
+    const allowItemRemoval = canRemoveItems(schema);
+    if (schema && isObjectType(schema.items)) {
+        const itemData = Array.isArray(formData)
+            ? formData[props.index]
+            : undefined;
+        return React.createElement(CollapsibleItemTemplate, {
+            key: props.itemKey,
+            buttonsProps: props.buttonsProps,
+            index: props.index,
+            data: itemData,
+            schema: schema,
+            formSchema: formContext === null || formContext === void 0 ? void 0 : formContext.schema,
+            allowItemRemoval: allowItemRemoval,
+            allowItemReorder: allowItemReorder,
+        }, props.children);
+    }
+    return React.createElement(SimpleItemTemplate, {
+        key: props.itemKey,
+        buttonsProps: props.buttonsProps,
+        index: props.index,
+        allowItemRemoval: allowItemRemoval,
+        allowItemReorder: allowItemReorder,
+    }, props.children);
+};
+function canRemoveItems(schema) {
+    const limeOptions = (schema === null || schema === void 0 ? void 0 : schema.lime) || {};
+    return limeOptions.allowItemRemoval !== false;
+}
+function canItemReorder(props, schema) {
+    const limeOptions = (schema === null || schema === void 0 ? void 0 : schema.lime) || {};
+    if (limeOptions.allowItemReorder === false) {
+        return false;
+    }
+    const { buttonsProps } = props;
+    return Boolean((buttonsProps === null || buttonsProps === void 0 ? void 0 : buttonsProps.hasMoveDown) || (buttonsProps === null || buttonsProps === void 0 ? void 0 : buttonsProps.hasMoveUp));
+}

package/dist/collection/components/form/templates/array-field-simple-item.js

@@ -5,8 +5,7 @@ export class SimpleItemTemplate extends React.Component {
         super(props);
         this.props = props;
         this.handleRemove = (event) => {
-            const { item, index } = this.props;
-            item.onDropIndexClick(index)(event);
+            this.props.buttonsProps.onRemoveItem(event);
         };
         this.setRemoveButton = (button) => {
             if (this.removeButton) {
@@ -22,12 +21,12 @@ export class SimpleItemTemplate extends React.Component {
         this.setRemoveButton(undefined);
     }
     render() {
-        const { item, allowItemReorder } = this.props;
+        const { allowItemReorder } = this.props;
         return React.createElement('div', {
             className: 'array-item limel-form-array-item--simple',
-            'data-reorder-id': String(this.props.dataIndex),
+            'data-reorder-id': String(this.props.index),
             'data-reorderable': allowItemReorder ? 'true' : 'false',
-        }, this.props.item.children, this.renderRemoveButton(item), this.renderDragHandle());
+        }, this.props.children, this.renderRemoveButton(), this.renderDragHandle());
     }
     renderDragHandle() {
         if (!this.props.allowItemReorder) {
@@ -37,13 +36,13 @@ export class SimpleItemTemplate extends React.Component {
             class: 'drag-handle',
         });
     }
-    renderRemoveButton(item) {
+    renderRemoveButton() {
         if (!this.props.allowItemRemoval) {
             return;
         }
         const props = {
             icon: 'trash',
-            disabled: !item.hasRemove,
+            disabled: !this.props.buttonsProps.hasRemove,
             ref: this.setRemoveButton,
         };
         return React.createElement(LIMEL_ICON_BUTTON, props);

package/dist/collection/components/form/templates/array-field.js

@@ -1,9 +1,8 @@
 import React from "react";
-import { isObjectType } from "../schema";
-import { CollapsibleItemTemplate } from "./array-field-collapsible-item";
-import { SimpleItemTemplate } from "./array-field-simple-item";
 import { renderDescription, renderTitle } from "./common";
 import Sortable from "sortablejs";
+import { ArrayFieldContext } from "./array-context";
+export const ARRAY_REORDER_EVENT = 'arrayReorder';
 const DRAG_HANDLE_SELECTOR = '[data-drag-handle]';
 const DRAGGABLE_ITEM_SELECTOR = '.array-item[data-reorderable="true"]';
 const DEFAULT_CONTAINER_CLASS = 'has-an-item-which-is-being-dragged';
@@ -13,7 +12,7 @@ const TOUCH_DRAG_DELAY_MS = 200; // Adds a short hold on touch (long-press) so s
 export class ArrayFieldTemplate extends React.Component {
     constructor(props) {
         super(props);
-        this.itemByIndex = new Map();
+        this.cachedContextValue = null;
         this.handleAddClick = (event) => {
             event.stopPropagation();
             this.props.onAddClick(event);
@@ -72,20 +71,10 @@ export class ArrayFieldTemplate extends React.Component {
                 this.scheduleDropElevationRemoval();
                 return;
             }
-            const targetItem = ((_a = this.props.items) !== null && _a !== void 0 ? _a : []).find((entry) => {
-                var _a;
-                return ((_a = entry.index) !== null && _a !== void 0 ? _a : -1) === draggedItemIndex;
-            });
-            if (!targetItem || typeof targetItem.onReorderClick !== 'function') {
-                this.scheduleDropElevationRemoval();
-                return;
-            }
-            requestAnimationFrame(() => {
-                const reorder = targetItem.onReorderClick(draggedItemIndex, toPosition);
-                if (typeof reorder === 'function') {
-                    reorder();
-                }
-            });
+            (_a = this.container) === null || _a === void 0 ? void 0 : _a.dispatchEvent(new CustomEvent(ARRAY_REORDER_EVENT, {
+                bubbles: true,
+                detail: { fromIndex: fromPosition, toIndex: toPosition },
+            }));
             this.scheduleDropElevationRemoval();
         };
         this.state = {
@@ -118,13 +107,12 @@ export class ArrayFieldTemplate extends React.Component {
         }
     }
     render() {
-        const controls = this.getItemControls();
-        const { ordered: orderedItems, byIndex } = this.getOrderedItems();
-        this.itemByIndex = byIndex;
-        return React.createElement('div', {}, renderTitle(this.props.title), renderDescription(this.props.schema.description), React.createElement('div', {
+        const orderedItems = this.getOrderedItems();
+        const contextValue = this.getContextValue();
+        return React.createElement(ArrayFieldContext.Provider, { value: contextValue }, React.createElement('div', {}, renderTitle(this.props.title), renderDescription(this.props.schema.description), React.createElement('div', {
             className: 'array-items',
             ref: this.setContainer,
-        }, orderedItems.map((item, index) => this.renderItem(item, index, controls))), this.renderAddButton());
+        }, orderedItems), this.renderAddButton()));
     }
     renderAddButton() {
         if (!this.props.canAdd) {
@@ -137,73 +125,40 @@ export class ArrayFieldTemplate extends React.Component {
             class: 'button-add-new',
         });
     }
-    getItemControls() {
-        return {
-            allowItemRemoval: this.canRemoveItems(),
-        };
-    }
-    renderItem(item, index, controls) {
-        var _a;
-        const { schema, formData, formContext } = this.props;
-        const itemIndex = (_a = item.index) !== null && _a !== void 0 ? _a : index;
-        const allowItemReorder = this.isItemReorderable(item);
-        if (isObjectType(schema.items)) {
-            return React.createElement(CollapsibleItemTemplate, {
-                key: item.key,
-                item: item,
-                data: Array.isArray(formData) ? formData[itemIndex] : undefined,
-                schema: schema,
-                formSchema: formContext.schema,
-                index: itemIndex,
-                allowItemRemoval: controls.allowItemRemoval,
-                allowItemReorder: allowItemReorder,
-            });
-        }
-        return React.createElement(SimpleItemTemplate, {
-            key: item.key,
-            item: item,
-            index: itemIndex,
-            dataIndex: itemIndex,
-            allowItemRemoval: controls.allowItemRemoval,
-            allowItemReorder: allowItemReorder,
-        });
-    }
     getOrderedItems() {
-        var _a, _b;
+        var _a;
         const items = (_a = this.props.items) !== null && _a !== void 0 ? _a : [];
-        const byIndex = new Map();
-        let entryIndex = 0;
-        for (const entry of items) {
-            byIndex.set((_b = entry.index) !== null && _b !== void 0 ? _b : entryIndex, entry);
-            entryIndex += 1;
+        if (items.length === 0) {
+            return [];
+        }
+        const byKey = new Map();
+        for (const [index, item] of items.entries()) {
+            byKey.set(index, item);
         }
         const ordered = [];
         const used = new Set();
         for (const index of this.state.order) {
-            const entry = byIndex.get(index);
+            const entry = byKey.get(index);
             if (!entry) {
                 continue;
             }
             ordered.push(entry);
             used.add(index);
         }
-        for (const [index, entry] of byIndex.entries()) {
+        for (const [index, entry] of byKey.entries()) {
             if (!used.has(index)) {
                 ordered.push(entry);
             }
         }
-        return {
-            ordered,
-            byIndex,
-        };
+        return ordered;
     }
     setupDragController() {
         if (!this.container || !this.canReorderItems()) {
             this.teardownDragController();
             return;
         }
-        const reorderableCount = this.getReorderableOrder().length;
-        if (reorderableCount < 2) {
+        const reorderableItems = this.container.querySelectorAll(`:scope > ${DRAGGABLE_ITEM_SELECTOR}`);
+        if (reorderableItems.length < 2) {
             this.teardownDragController();
             return;
         }
@@ -249,31 +204,6 @@ export class ArrayFieldTemplate extends React.Component {
         const limeOptions = (schema === null || schema === void 0 ? void 0 : schema.lime) || {};
         return limeOptions.allowItemReorder !== false;
     }
-    canRemoveItems() {
-        const schema = this.props.schema;
-        const limeOptions = (schema === null || schema === void 0 ? void 0 : schema.lime) || {};
-        return limeOptions.allowItemRemoval !== false;
-    }
-    isItemReorderable(item) {
-        return (this.canReorderItems() &&
-            Boolean((item === null || item === void 0 ? void 0 : item.hasMoveDown) || (item === null || item === void 0 ? void 0 : item.hasMoveUp)));
-    }
-    isIndexReorderable(index) {
-        const item = this.itemByIndex.get(index);
-        if (!item) {
-            return false;
-        }
-        return this.isItemReorderable(item);
-    }
-    getReorderableOrder(order = this.state.order) {
-        const result = [];
-        for (const index of order) {
-            if (this.isIndexReorderable(index)) {
-                result.push(index);
-            }
-        }
-        return result;
-    }
     readOrderFromDom() {
         if (!this.container) {
             return [];
@@ -348,6 +278,20 @@ export class ArrayFieldTemplate extends React.Component {
         return true;
     }
     extractIndices(items = []) {
-        return (items !== null && items !== void 0 ? items : []).map((item, index) => { var _a; return (_a = item.index) !== null && _a !== void 0 ? _a : index; });
+        return (items !== null && items !== void 0 ? items : []).map((_, index) => index);
+    }
+    getContextValue() {
+        var _a;
+        const schema = this.props.schema;
+        const formData = ((_a = this.props.formData) !== null && _a !== void 0 ? _a : []);
+        if (this.cachedContextValue &&
+            this.cachedSchema === schema &&
+            this.cachedFormData === formData) {
+            return this.cachedContextValue;
+        }
+        this.cachedSchema = schema;
+        this.cachedFormData = formData;
+        this.cachedContextValue = { arraySchema: schema, formData };
+        return this.cachedContextValue;
     }
 }

package/dist/collection/components/form/templates/index.js

@@ -1,3 +1,4 @@
 export * from './field';
 export * from './array-field';
+export * from './array-field-item';
 export * from './object-field';

package/dist/collection/components/form/templates/object-field.js

@@ -1,17 +1,19 @@
-import React from "react";
+import React, { useContext } from "react";
 import { renderDescription, renderTitle } from "./common";
 import { GridLayout } from "./grid-layout";
 import { RowLayout } from "./row-layout";
 import { getHelpComponent } from "../help";
+import { ArrayFieldContext } from "./array-context";
 export const ObjectFieldTemplate = (props) => {
-    const id = props.idSchema.$id;
+    const arrayContext = useContext(ArrayFieldContext);
+    const id = props.fieldPathId.$id;
+    if (arrayContext && id !== 'root') {
+        return React.createElement(ArrayFieldContext.Provider, { value: null }, renderProperties(props.properties, props.schema));
+    }
     if (id === 'root' || !isCollapsible(props.schema)) {
         return renderFieldWithTitle(props);
     }
-    if (isCollapsible(props.schema)) {
-        return renderCollapsibleField(props);
-    }
-    return renderProperties(props.properties, props.schema);
+    return renderCollapsibleField(props);
 };
 function renderFieldWithTitle(props) {
     return React.createElement(React.Fragment, {}, renderSectionHeader(props), renderDescription(props.description), renderProperties(props.properties, props.schema));
@@ -30,17 +32,19 @@ function renderCollapsibleField(props) {
     });
     return React.createElement('limel-collapsible-section', {
         header: props.title,
-        id: getSchemaObjectPropertyPath(props.formContext.schema, props.idSchema),
+        id: getSchemaObjectPropertyPath(props.registry.formContext.schema, props.fieldPathId),
         'is-open': defaultOpen,
     }, helpElement, renderDescription(props.description), renderProperties(props.properties, props.schema));
 }
-function getSchemaObjectPropertyPath(schema, subSchema) {
+function getSchemaObjectPropertyPath(schema, fieldPathId) {
     var _a, _b;
     const refPrefixLength = 2;
     const matchAllForwardSlashes = /\//g;
-    const rootPath = (_a = schema.$ref) === null || _a === void 0 ? void 0 : _a.replace(matchAllForwardSlashes, '.').slice(refPrefixLength);
-    const subSchemaPath = (_b = subSchema.$id) === null || _b === void 0 ? void 0 : _b.replace('_', '.properties.');
-    return subSchemaPath.replace('root', rootPath);
+    const rootPath = (_b = (_a = schema.$ref) === null || _a === void 0 ? void 0 : _a.replace(matchAllForwardSlashes, '.').slice(refPrefixLength)) !== null && _b !== void 0 ? _b : '';
+    const subSchemaPath = fieldPathId.path
+        .map((segment) => `.properties.${segment}`)
+        .join('');
+    return `${rootPath}${subSchemaPath}`;
 }
 function renderProperties(properties, schema) {
     var _a;

package/dist/collection/components/form/validation-display.js

@@ -0,0 +1,75 @@
+import { isEmpty, capitalize } from "lodash-es";
+/**
+ * Check whether a form field value is non-empty.
+ * Treats `null`, `undefined`, `''`, empty arrays,
+ * and empty plain objects as "no value".
+ *
+ * @param value - the current field value
+ * @returns `true` when the field holds meaningful data
+ */
+export function hasValue(value) {
+    if (value === null || value === undefined || value === '') {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (value instanceof Date) {
+        return true;
+    }
+    if (typeof value === 'object') {
+        return !isEmpty(value);
+    }
+    return true;
+}
+/**
+ * Determine whether a field should be displayed as invalid.
+ *
+ * A field with errors is shown as invalid only when the user has
+ * interacted with it, it already contains a value, or it is optional.
+ * This avoids showing errors on untouched required fields before the
+ * user has had a chance to fill them in.
+ *
+ * @param field - the current field state
+ * @param field.hasErrors - whether the field currently has validation errors
+ * @param field.modified - whether the user has interacted with the field
+ * @param field.hasValue - whether the field holds a non-empty value
+ * @param field.required - whether the field is required
+ * @returns `true` when the field should render in an invalid state
+ */
+export function isFieldInvalid(field) {
+    return (field.hasErrors && (field.modified || field.hasValue || !field.required));
+}
+/**
+ * Check whether a field should be marked as required.
+ *
+ * A field is required when the schema marks it as `required` or
+ * when it specifies a positive `minItems` constraint.
+ *
+ * @param field - the current field state
+ * @param field.required - the `required` flag from the schema/props
+ * @param field.minItems - the `minItems` value from the schema (0 if unset)
+ * @returns `true` when the field is required
+ */
+export function isFieldRequired(field) {
+    return field.required || field.minItems > 0;
+}
+/**
+ * Return the helper text to display beneath a field.
+ *
+ * When validation errors exist the first error message is returned
+ * (capitalized). Otherwise falls back to `fallbackText` if provided,
+ * then to `description`.
+ *
+ * @param errors - array of validation error strings (may be `null`)
+ * @param description - the schema description for the field
+ * @param fallbackText - optional text that takes priority over `description`
+ *   when there are no errors (e.g. a custom `helperText` prop)
+ * @returns the string to show as helper text
+ */
+export function getErrorText(errors, description, fallbackText) {
+    if ((errors === null || errors === void 0 ? void 0 : errors.length) > 0) {
+        return capitalize(errors[0]);
+    }
+    return fallbackText || description;
+}

package/dist/collection/components/form/validator.js

@@ -0,0 +1,10 @@
+import { customizeValidator } from "@rjsf/validator-ajv8";
+import { isInteger } from "./validators";
+/**
+ * Shared RJSF validator configured with custom formats and ajv options.
+ * Use this single instance wherever the RJSF v6 API requires a validator.
+ */
+export const rjsfValidator = customizeValidator({
+    customFormats: { integer: isInteger },
+    ajvOptionsOverrides: { allErrors: true, multipleOfPrecision: 2 },
+});

package/dist/collection/components/form/widgets/code-editor.js

@@ -62,7 +62,7 @@ export class CodeEditor extends React.Component {
             this.setState({ validationError, modified: true });
             return;
         }
-        props.onChange(value);
+        props.onChange(value, props.fieldPathId.path);
         this.setState({ validationError: '', modified: true });
     }
 }

package/dist/collection/components/form/widgets/select.js

@@ -48,10 +48,11 @@ export class Select extends React.Component {
     }
 }
 function createOption(item) {
+    var _a;
     return {
         text: item.label,
         value: item.value,
-        disabled: !!item.schema.readOnly,
+        disabled: !!((_a = item.schema) === null || _a === void 0 ? void 0 : _a.readOnly),
     };
 }
 function findValue(value, options) {

package/dist/collection/components/picker/picker.js

@@ -383,6 +383,7 @@ export class Picker {
     }
     handleChange(event) {
         event.stopPropagation();
+        this.textValue = '';
         let newValue = null;
         if (this.multiple) {
             const chips = event.detail;

package/dist/collection/components/table/table.js

@@ -612,16 +612,16 @@ export class Table {
     render() {
         var _a, _b;
         const totalRows = (_a = this.totalRows) !== null && _a !== void 0 ? _a : this.data.length;
-        return (h(Host, { key: 'e615540df33a213dcdcdecfbaf4a62add8a56343', class: {
+        return (h(Host, { key: '68ff4552c148835bc927f9ce5587e8073c2cbf3d', class: {
                 'has-low-density': this.layout === 'lowDensity',
                 'has-pagination-on-top': this.paginationLocation === 'top',
-            } }, h("div", { key: '912374e7d1308708945dde7e94366a9e20ce8236', id: "tabulator-container", class: {
+            } }, h("div", { key: '3a7cf6c12e83db4b17f2bffdad17c113c7c7ca45', id: "tabulator-container", class: {
                 'has-pagination': totalRows > this.pageSize,
                 'has-aggregation': this.hasAggregation(this.columns),
                 'has-movable-columns': this.movableColumns,
                 'has-rowselector': this.selectable,
                 'has-selection': (_b = this.tableSelection) === null || _b === void 0 ? void 0 : _b.hasSelection,
-            } }, h("div", { key: 'ccfead61db80a9d54631daecb950c352cf41bbc8', id: "tabulator-loader", style: { display: this.loading ? 'flex' : 'none' } }, h("limel-spinner", { key: '2f095d05a6d972e008467d54e71520e2848b6d2e', size: "large" })), this.renderEmptyMessage(), this.renderSelectAll(), h("div", { key: '1c200d356c582e35bce4b0f02bfc187e42a072ec', id: "tabulator-table" }))));
+            } }, h("div", { key: '1aeea14d08105a4fbc95d238122ce9f4574a296b', id: "tabulator-loader", style: { display: this.loading ? 'flex' : 'none' } }, h("limel-spinner", { key: '496c560a362f469616a23801902d9a748b1293ad', size: "large" })), this.renderEmptyMessage(), this.renderSelectAll(), h("div", { key: '1b9e129b2e30b6c8c9256f612dc4cd9fa53b3afc', id: "tabulator-table" }))));
     }
     renderSelectAll() {
         var _a, _b, _c;
@@ -709,7 +709,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "mode",
                 "defaultValue": "'local'"
             },
@@ -736,7 +736,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "layout"
             },
             "pageSize": {
@@ -755,7 +755,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "page-size"
             },
             "totalRows": {
@@ -774,7 +774,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "total-rows"
             },
             "sorting": {
@@ -842,7 +842,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "movable-columns"
             },
             "sortableColumns": {
@@ -861,7 +861,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "sortable-columns",
                 "defaultValue": "true"
             },
@@ -881,7 +881,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "loading",
                 "defaultValue": "false"
             },
@@ -901,7 +901,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "page",
                 "defaultValue": "FIRST_PAGE"
             },
@@ -964,7 +964,7 @@ export class Table {
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": false,
+                "reflect": true,
                 "attribute": "selectable"
             },
             "selection": {

package/dist/esm/{_assignValue-DkGAX8ec.js → _assignValue-DOEO9byf.js}

@@ -1,6 +1,28 @@
-import { b as baseAssignValue } from './_baseAssignValue-C8Uwn8zr.js';
+import { d as defineProperty } from './_defineProperty-yVdnnt__.js';
 import { e as eq } from './eq-D7VMHFyO.js';
 
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
 /** Used for built-in method references. */
 var objectProto = Object.prototype;
 
@@ -25,4 +47,4 @@ function assignValue(object, key, value) {
   }
 }
 
-export { assignValue as a };
+export { assignValue as a, baseAssignValue as b };

package/dist/esm/{_baseForOwn-CfpQNnvA.js → _baseEach-CL_-rBMy.js}

@@ -1,4 +1,5 @@
-import { k as keys } from './_baseIsEqual-BvHnKRmD.js';
+import { k as keys } from './_baseIsEqual-BfXMsuGh.js';
+import { i as isArrayLike } from './isArrayLike-D1QkaJU2.js';
 
 /**
  * Creates a base function for methods like `_.forIn` and `_.forOwn`.
@@ -49,4 +50,43 @@ function baseForOwn(object, iteratee) {
   return object && baseFor(object, iteratee, keys);
 }
 
-export { baseForOwn as b };
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+        index = -1,
+        iterable = Object(collection);
+
+    while ((++index < length)) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+export { baseEach as a, baseFor as b, baseForOwn as c };