Namespace Merging in TypeScript

Namespace merging in TypeScript allows you to combine multiple namespaces into a single, unified namespace. This is particularly useful for modularizing code and preventing naming conflicts when integrating libraries or components. This challenge asks you to implement a function that merges a collection of namespaces into a single target namespace.

Problem Description

You are tasked with creating a TypeScript function called mergeNamespaces that takes two arguments: a target namespace object and an array of namespace objects to merge into the target. The function should iterate through the array of namespaces and merge each one into the target namespace. Merging means that all properties (including functions and variables) from the source namespace are added to the target namespace. If a property already exists in the target namespace, it should be overwritten by the property from the source namespace.

Key Requirements:

• The function must handle various data types for properties within the namespaces (strings, numbers, booleans, functions, objects, arrays).
• The function should not modify the original source namespaces. It should only modify the target namespace.
• The function should handle empty namespaces gracefully (both the target and the source namespaces).
• The function should handle cases where the input array of namespaces is empty.

Expected Behavior:

After calling mergeNamespaces, the target namespace should contain all the properties from all the source namespaces. If a property exists in multiple source namespaces, the value from the last source namespace encountered should be used.

Edge Cases to Consider:

• Empty target namespace.
• Empty array of namespaces to merge.
• Namespaces with overlapping property names.
• Namespaces containing functions.
• Namespaces containing nested objects.

Examples

Example 1:

Input:
targetNamespace = { a: 1, b: "hello" };
namespacesToMerge = [{ c: 2, d: "world" }, { a: 3, e: true }];

Output:
{ a: 3, b: "hello", c: 2, d: "world", e: true }

Explanation:
The function merges namespacesToMerge into targetNamespace. 'a' is overwritten with the value from the second namespace. 'b', 'c', 'd', and 'e' are added to the target namespace.

Example 2:

Input:
targetNamespace = {};
namespacesToMerge = [{ x: 10 }, { y: "typescript" }, {}];

Output:
{ x: 10, y: "typescript" }

Explanation:
The function merges the namespaces into an initially empty target namespace. The empty namespace is gracefully handled.

Example 3: (Edge Case)

Input:
targetNamespace = { func: () => { console.log("original"); } };
namespacesToMerge = [{ func: () => { console.log("merged"); } }];

Output:
{ func: () => { console.log("merged"); } }

Explanation:
The function correctly overwrites the function property in the target namespace with the function from the source namespace.

Constraints

• The target namespace and namespaces to merge will be plain JavaScript objects.
• The array of namespaces to merge will contain plain JavaScript objects.
• The input array namespacesToMerge can contain up to 100 namespaces.
• The function should execute in under 100ms for typical inputs.

Notes

Consider using a loop to iterate through the namespacesToMerge array. Within the loop, iterate through the properties of each source namespace and assign them to the target namespace. Remember to avoid modifying the original source namespaces. Think about how to handle potential type errors gracefully. The core of the solution involves iterating and assigning properties, but ensuring immutability and handling edge cases are crucial for a robust solution.