Implementing an Immutability Helper

In many programming paradigms, especially functional programming and when working with state management libraries, immutability is a crucial concept. Immutability ensures that data structures cannot be changed after they are created, leading to more predictable code, easier debugging, and safer concurrent operations. This challenge asks you to build a helper function that allows for shallow immutably updating of nested data structures.

Problem Description

Your task is to implement a function, let's call it immutableUpdate, that takes three arguments:

1. originalObject: The data structure (object or array) to be updated.
2. path: A sequence of keys or indices representing the path to the property to be updated. This path can be a string (e.g., "user.address.city") or an array of strings/numbers (e.g., ["user", "address", "city"] or ["items", 0, "name"]).
3. newValue: The new value to be assigned to the property at the specified path.

The function should return a new object or array that is a deep copy of originalObject up to the point of modification, with the specified newValue applied at the path. All other parts of the originalObject should remain the same, but crucially, the returned structure should not share any mutable references with the original for the modified path and its ancestors. This is a shallow immutability helper, meaning only the objects/arrays along the path to the modification are duplicated; properties of those objects that are themselves objects or arrays are not recursively deep-copied unless they are part of the path.

Key Requirements:

• The originalObject must not be mutated.
• The function must handle nested objects and arrays.
• The path can be provided as a dot-separated string or an array of keys/indices.
• If any part of the path does not exist in the originalObject, the function should create it as a new object or array as needed to accommodate the update.

Expected Behavior: When immutableUpdate is called, it should return a completely new data structure. If you were to compare the returned structure with the original using reference equality, they should differ if any modification occurred.

Edge Cases:

• Updating a root-level property.
• Updating a property deep within nested structures.
• Updating an element in an array.
• Path does not exist, requiring creation of new intermediate objects/arrays.
• Empty path.
• originalObject is null or undefined.

Examples

Example 1:

Input:
originalObject = {
  user: {
    name: "Alice",
    address: {
      street: "123 Main St",
      city: "Anytown"
    }
  },
  settings: {
    theme: "dark"
  }
}
path = "user.address.city"
newValue = "Newville"

Output:
{
  user: {
    name: "Alice",
    address: {
      street: "123 Main St",
      city: "Newville" // Updated value
    }
  },
  settings: {
    theme: "dark" // Unchanged
  }
}

Explanation: A new object is returned. The path `user.address.city` was followed. A new object for `address` was created, and a new object for `user` was created, both containing copies of the unchanged properties from the original. `city` was updated to "Newville". The `settings` object remains a reference to the original `settings` object as it was not part of the modified path.

Example 2:

Input:
originalObject = [
  { id: 1, name: "Apple" },
  { id: 2, name: "Banana" }
]
path = ["0", "name"] // or path = ["0", 0] depending on interpretation, let's clarify: use array of string/number
newValue = "Apricot"

Output:
[
  { id: 1, name: "Apricot" }, // Updated name
  { id: 2, name: "Banana" }  // Unchanged
]

Explanation: A new array is returned. The path `[0].name` was followed. A new object for the first element (index 0) was created, and a new array was created. The name of the first element was updated to "Apricot".

Example 3:

Input:
originalObject = { a: 1 }
path = "b.c.d"
newValue = 10

Output:
{
  a: 1,
  b: {
    c: {
      d: 10 // Newly created path and value
    }
  }
}

Explanation: The original object `{ a: 1 }` is not mutated. A new object is returned. Since `b` did not exist, a new object for `b` was created. Since `c` did not exist within `b`, a new object for `c` was created. Finally, `d` was set to `10` within `c`.

Constraints

• The originalObject can be a JavaScript-like object (key-value pairs) or an array.
• The path can be a dot-separated string (e.g., "a.b.c") or an array of strings/numbers (e.g., ["a", "b", "c"] or ["items", 0, "name"]). Numbers in the path array represent array indices.
• The newValue can be any primitive value, object, or array.
• The function should be reasonably efficient, avoiding unnecessary deep copying. Performance should be acceptable for typical application state sizes.
• Handle cases where originalObject is null or undefined gracefully (e.g., return an appropriately updated new structure).

Notes

• Consider how to parse the dot-separated string path into an array of keys/indices.
• You'll need to recursively traverse the originalObject based on the parsed path.
• At each step of the traversal, create a new object or array to hold the updated subtree.
• Be mindful of differentiating between updating an object property and an array element.
• When creating new intermediate structures, ensure they are copies of the original's children that are not on the path being updated. For example, if updating user.address.city, the user object needs to be copied, and the address object within user needs to be copied. However, if user had another property like profile which is an object, profile itself would be shallow-copied (referenced) into the new user object, not deep-copied.