@limetech/lime-elements 39.13.3 → 39.14.1

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/text-editor/prosemirror-adapter/plugins/trigger/create-html-inserter.js

@@ -1,10 +1,10 @@
 import { DOMParser } from "prosemirror-model";
-export const createHtmlInserter = (view, contentConverter, startPos, dispatchTransaction) => {
+export const createHtmlInserter = (view, contentConverter, trigger, dispatchTransaction) => {
     const schema = view.state.schema;
     return async (input) => {
         const container = document.createElement('span');
         container.innerHTML = await contentConverter.parseAsHTML(input, schema);
         const fragment = DOMParser.fromSchema(schema).parse(container).content;
-        dispatchTransaction(view, startPos, fragment);
+        dispatchTransaction(view, trigger.position, fragment);
     };
 };

package/dist/collection/components/text-editor/prosemirror-adapter/plugins/trigger/factory-helpers/append-transaction-handler.js

@@ -12,6 +12,13 @@ export const getAppendTransactionHandler = (getCurrentView, getActiveTrigger, re
             resetActiveTrigger();
             return;
         }
+        for (const transaction of transactions) {
+            if (transaction.docChanged) {
+                activeTrigger.position = transaction.mapping.map(activeTrigger.position, 
+                // eslint-disable-next-line unicorn/no-array-method-this-argument -- ProseMirror Mapping#map(pos, assoc), not Array#map
+                -1);
+            }
+        }
         monitorTriggeredText(newState.doc, activeTrigger, newState.selection.from, contentConverter, getCurrentView());
     };
 };

package/dist/collection/components/text-editor/prosemirror-adapter/plugins/trigger/inserter.js

@@ -2,7 +2,7 @@ import { createHtmlInserter } from "./create-html-inserter";
 export const inserterFactory = (view, contentConverter, trigger) => {
     return {
         insert: createNodeAndTextInserter(view, trigger),
-        insertHtml: createHtmlInserter(view, contentConverter, trigger.position, dispatchTransaction),
+        insertHtml: createHtmlInserter(view, contentConverter, trigger, dispatchTransaction),
         stopTrigger: () => stopTriggerTransaction(view),
     };
 };

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 };

package/dist/esm/{_baseIsEqual-BvHnKRmD.js → _baseIsEqual-BfXMsuGh.js}

@@ -3,7 +3,7 @@ import { g as getNative, t as toSource } from './_getNative-aN4R8EiP.js';
 import { r as root, b as baseGetTag, f as freeGlobal, S as Symbol } from './isObject-BJQylLSL.js';
 import { i as isArray } from './isArray-B8VKuhvH.js';
 import { i as isObjectLike } from './isObjectLike-oiMYqRQ0.js';
-import { i as isLength, a as isIndex, b as isArrayLike } from './isArrayLike-bWHU4ebg.js';
+import { a as isLength, b as isIndex, i as isArrayLike } from './isArrayLike-D1QkaJU2.js';
 
 /* Built-in method references that are verified to be native. */
 var WeakMap = getNative(root, 'WeakMap');
@@ -1539,4 +1539,4 @@ function baseIsEqual(value, other, bitmask, customizer, stack) {
   return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
 }
 
-export { MapCache as M, Set as S, Uint8Array as U, SetCache as a, baseIsEqual as b, cacheHas as c, isTypedArray as d, isArguments as e, isPrototype as f, getTag as g, baseKeys as h, isBuffer as i, Stack as j, keys as k, arrayPush as l, arrayLikeKeys as m, stubArray as n, overArg as o, getSymbols as p, baseGetAllKeys as q, baseUnary as r, setToArray as s, nodeUtil as t, getAllKeys as u };
+export { MapCache as M, Stack as S, Uint8Array as U, isTypedArray as a, isArguments as b, SetCache as c, cacheHas as d, baseIsEqual as e, baseTimes as f, Set as g, getTag as h, isBuffer as i, isPrototype as j, keys as k, baseKeys as l, getSymbols as m, baseUnary as n, nodeUtil as o, getAllKeys as p, arrayPush as q, arrayLikeKeys as r, setToArray as s, overArg as t, stubArray as u, baseGetAllKeys as v };

package/dist/esm/{_baseIteratee-DFBCJcMA.js → _baseIteratee-kS1-0_xD.js}

@@ -1,8 +1,8 @@
-import { M as MapCache, j as Stack, b as baseIsEqual, k as keys, e as isArguments } from './_baseIsEqual-BvHnKRmD.js';
+import { M as MapCache, S as Stack, e as baseIsEqual, k as keys, b as isArguments } from './_baseIsEqual-BfXMsuGh.js';
 import { S as Symbol, i as isObject } from './isObject-BJQylLSL.js';
 import { i as isArray } from './isArray-B8VKuhvH.js';
 import { i as isSymbol } from './isSymbol-ClAke5ga.js';
-import { i as isLength, a as isIndex } from './isArrayLike-bWHU4ebg.js';
+import { a as isLength, b as isIndex } from './isArrayLike-D1QkaJU2.js';
 import { i as identity } from './identity-CK4jS9_E.js';
 
 /**
@@ -596,4 +596,4 @@ function baseIteratee(value) {
   return property(value);
 }
 
-export { toKey as a, baseIteratee as b, castPath as c, baseGet as d, arrayMap as e, get as g, hasPath as h, toString as t };
+export { arrayMap as a, baseGet as b, baseIteratee as c, castPath as d, toKey as e, hasPath as f, get as g, hasIn as h, stringToPath as s, toString as t };

package/dist/esm/_commonjsHelpers-B85MJLTf.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs as g };

package/dist/esm/_getAllKeysIn-BKpeslPJ.js

@@ -0,0 +1,113 @@
+import { j as isPrototype, r as arrayLikeKeys, t as overArg, u as stubArray, q as arrayPush, m as getSymbols, v as baseGetAllKeys } from './_baseIsEqual-BfXMsuGh.js';
+import { i as isObject } from './isObject-BJQylLSL.js';
+import { i as isArrayLike } from './isArrayLike-D1QkaJU2.js';
+
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object),
+      result = [];
+
+  for (var key in object) {
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own and inherited enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush(result, getSymbols(object));
+    object = getPrototype(object);
+  }
+  return result;
+};
+
+/**
+ * Creates an array of own and inherited enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeysIn(object) {
+  return baseGetAllKeys(object, keysIn, getSymbolsIn);
+}
+
+export { getAllKeysIn as a, getSymbolsIn as b, getPrototype as g, keysIn as k };