Shim Object.assign?

[kitsonk]

Instead of creating the core/lang::assign as it is now, wouldn't it be better to shim so it offloads to native assign (and keeps it functionally aligned?)... something like:

interface ObjectConstructor {
    assign(target: any, ...sources: any[]): any;
}

/* Adapted from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill */
let assign = Object.assign ? Object.assign : function(target: any, ...sources: any[]): any {
    'use strict';
    if (typeof target === 'undefined' || target === null) {
        throw new TypeError('Cannot convert first argument to object');
    }

    const to = Object(target);
    for (let i = 0; i < sources.length; i++) {
        let nextSource = sources[i];
        if (typeof nextSource === 'undefined' || nextSource === null) {
            continue;
        }
        nextSource = Object(nextSource);

        const keysArray = Object.keys(Object(nextSource));
        for (let nextIndex = 0; nextIndex < keysArray.length; nextIndex++) {
            const nextKey = keysArray[nextIndex];
            const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
            if (typeof desc !== 'undefined' && desc.enumerable) {
                to[nextKey] = nextSource[nextKey];
            }
        }
    }
    return to;
};

[kitsonk]

I guess it should use some sort of has() flag sort of thing too, so when we settle on how has build optimisation will work...

[bryanforbes]

We'd need to update the internal _mixin function to behave more like Object.assign, but I don't see a problem doing that. Then lang.assign, lang.deepAssign, lang.mixin, and lang.deepMixin would all be able to accept primitive types without throwing. What do you think, @kfranqueiro?

[bryanforbes]

I just spoke with @mwistrand and he told me that the internal _mixin function already behaves like Object.assign, so this might not be as hard as we first thought.

[mwistrand]

Updating lang.assign to delegate to Object.assign when available will be easy. Doing the same for lang.deepAssign might require a bit more effort.

EDIT: On second thought, since lang.deepAssign has to check the types on each source item, delegating to Object.assign doesn't even make sense.

[kitsonk]

EDIT: On second thought, since lang.deepAssign has to check the types on each source item, delegating to Object.assign doesn't even make sense.

Agreed, there doesn't seen to be an easy way to offload onto the native implementation.