feat(omit-deep): add function and tests

[geomus]

an alternative for https://www.npmjs.com/package/omit-deep-lodash using ramda.

[crash7]

Thanks for the contribution!
The docs are generated automatically for every release, so no need to push those in the PR.

[crash7]

Did you check this? https://github.com/MichaelQQ/deepOmit/blob/master/index.js#L1

[crash7]

@nfantone could you take a look whenever you have some time?

@geomus probably additional test cases (and formatting in those when you have big objects) would be ideal 🙏🏻

[nfantone]

This would be the equivalent of map(omitDeep(['a', 'b', 'c']) — I don't see much value in supporting an array of objects as input, if that makes sense.

The case of a value within an object being an array should still be handled appropriately, though.

[nfantone]

We should also test expected outcomes from non-object-like values: null, undefined, false, true, new Map(), new Set(), number.

[nfantone]

Having another test where the keys are repeated inside different nested objects would be ideal, as well.

    const obj = {
      a: 1,
      b: 2,
      c: {
        d: 3,
        e: 4
      },
      g: {
        d: 3,
        e: 4
      },
    };
    expect(omitDeep(['d', 'e'], obj)).toEqual({ a: 1, b: 2, c: {}, g: {} });

[nfantone]

The same goes for keys nested within objects in lists.

const obj = {
  a: 1,
  b: 2,
  c: {
    d: 3,
    e: 4,
  },
  j: [
    {
      d: 44,
      e: 23,
      f: {
        d: 99,
        w: 8,
      },
    },
  ],
}

expect(omitDeep(['d', 'e'], obj)).toEqual({a: 1, b: 2, c: {}, j: [{ f: { w: 8 } } ]})

[nfantone]

What's the use case of this? I believe we can remove it. There's an expectation that all arguments are always going to be supplied to pure ramda functions.

[nfantone]

I think we can remove this.

[nfantone]

I suggest we change the jsdoc to something like:

/**
 * Recursively omit the specified keys from an object.
 * The keys are omitted from the object itself and all its nested objects.
 *
 * @template T
 * @see https://github.com/jonschlinkert/omit-deep/tree/master
 * @example
 *  omitDeep(['b', 'd'], { a: 1, b: 2, c: { d: 3, e: 4 } }); // { a: 1, c: { e: 4 } }
 * @param {string[]} props The list of keys to omit.
 * @param {T} input The value to omit keys from.
 * @returns {T} A new value with the specified keys omitted.
 */

• The function seems to accept any kind of values and it always return the same value passed to it. So a @template would be useful here.
• The @param order looks to be inverted. input is the second argument to the function.
• Would be nice if the @example showed the removal of a deeply nested property.

[nfantone]

These initial conditions could be merged or simplified — i.e.: the Array.isArray check is carried out several times, in different places.

[nfantone]

Based on all comments above, I think a reasonable rewrite of omitDeep could look like this.

function omitDeep(props, input) {
  if (!isObject(input)) {
    return input
  }

  function omitDeepOwn(obj) {
    if (Array.isArray(obj)) {
      return obj.map(omitDeepOwn)
    }

    if (isObject(obj)) {
      const o = {}
      for (const [key, value] of Object.entries(obj)) {
        o[key] = omitDeepOwn(value)
      }
      return omit(props, o)
    }

    return obj
  }

  return omitDeepOwn(input)
}

What do you think?