Should detect whole state spreading

With a given code

const mapState = ({ page, direction, ...state }) => ({
  page,
  direction,
  isLoading: isLoading(state)
})

memoize state should not react to any state change, as it would.

Posible solutions:

1. Currently, memoize react on key get, but it could react on key read. This will require all objects to be wrapped by something with valueOf/toString. They key will be added to tracking if someone “read” it, or “return” it. Could affect performance. Unstable.

2. Track such situations and encourage a user to change the code

• cast function to string, and search for spread operator (unstable)
• detect then all keys of state used, and inform user of a potential problem. Easy to do, could be enabled by default in dev mode.

[theKashey]

There are 2 polyfills, one is simple - could set a trap on set/get/call. Could be done via object.defineProperty. Second is much more complex, and also patches Object methods, to work with “fake” polyfill.

Unfortunately, I’ve failed to solve this task. (for now, looking other ways)

babel-plugin-transform-object-rest-spread destroys the proxy. It just gets all the props outsite “the state”, and stores in another object, already not controlled by me. I could count or “all” methods as used, or all as not used. But I also could trigger on “enumeration”/spreading.

[theKashey]

As long there is no way to distinguish object spread and deep-equal - that’s really no way to solve this. Solution made:

1. proxyequal adds a hook to ownKeys injecting the “enumeration trap” then someone going to enumerate object. Not affecting “normal” objects, and production. In case of access to that object proxyequal will inform about enumeration, and memoize-state provide a link to a function.

Solution tried:

1. Via ownKeys add the “enum-start” and the “enum-end” guard keys. On access the key during enumeration - return something like {[Symbol.toPrimitive]:....}, deferring key access recording. But, if no one will cast “result” to primitive type - it will not work. And nobody will.
2. During the spread - record all primitive types, but not objects, as long access into objects are still tracked. This will fail situation like state.values ? state.oneKey : state:anotherKey or deep/shallow-compare.

Followup - let user disable this notification, or enable only for top-level keys.