Frontend developer II

Create a curry function that takes a single function as its argument and returns a new function. This returned function should accept one argument at a time and can be called multiple times until it receives the minimum number of arguments needed (based on how many arguments the original function requires). Once the required number of arguments has been provided, the original function should be called with those arguments.

Examples:

1. 
function add(a, b) {
 return a + b;
}

const curriedAdd = curry(add);
curriedAdd(3)(4); // 7

const alreadyAddedThree = curriedAdd(3);
alreadyAddedThree(4); // 7

2. 
function multiplyThreeNumbers(a, b, c) {
 return a * b * c;
}

const curriedMultiplyThreeNumbers = curry(multiplyThreeNumbers);
curriedMultiplyThreeNumbers(4)(5)(6); // 120

const containsFour = curriedMultiplyThreeNumbers(4);
const containsFourMulFive = containsFour(5);
containsFourMulFive(6); // 120

Implement a function **`jsonStringify`**,  that converts a JavaScript value into a JSON string.

- Only JSON-serializable values (i.e. boolean, number, **`null`**, array, object) will be present in the input value.
- Ignore the optional parameters in the original API.

Examples:

jsonStringify({ foo: 'bar' }); // '{"foo":"bar"}'
jsonStringify({ foo: 'bar', bar: [1, 2, 3] }); // '{"foo":"bar","bar":[1,2,3]}'
jsonStringify({ foo: true, bar: false }); // '{"foo":true,"bar":false}'

Write a function that performs the breadth-first search (BFS) algorithm on a directed graph represented in adjacency list format, starting from a specified node.

BFS is used to traverse a graph or tree, beginning at the root node and exploring all neighbouring nodes at the current depth level before proceeding to nodes at the next level. The function should return an array containing the nodes of the graph in the order they were visited. While visiting neighbouring nodes can be done in any order, for this task, ensure that you visit each node's neighbours from left to right.

const graph1 = {
 A: ['B', 'C', 'D'],
 B: ['E', 'F'],
 C: ['G', 'H'],
 D: ['I', 'J'],
 E: ['D'],
 F: [],
 G: [],
 H: [],
 I: [],
 J: [],
};

const graph2 = {
 'A': ['B', 'C'],
 'B': ['D', 'E'],
 'C': ['F', 'G'],
 'D': [],
 'E': [],
 'F': [],
 'G': [],
};

Create a function called memoize(func) that takes a single function parameter, func, and returns a memoized version of that function. You can assume that func will only accept strings or numbers as its arguments.

Design a desktop email client that can send and receive email messages given an email provider service.


What are the core functionalities needed?

- Sending email messages to an SMTP server.
- Retrieving email messages from an IMAP server.
- Access email messages already on the device.

What operating systems does the app need to support?

The popular ones: are Windows, macOS, and Linux/Ubuntu.

What email services/accounts need to be supported?

We don't have to focus on that aspect for this question. Assume that the user can make authenticated requests to preconfigured SMTP/IMAP servers to send/retrieve emails successfully.

Many native desktop email clients like Apple Mail, Outlook, and Mailspring allow users to connect to multiple email services like iCloud Mail, Gmail, and Exchange to show emails from multiple services within the app. However, that is beyond the scope of this question.

Does the application need to work offline?

Yes, where possible. Outgoing email messages should be saved and sent out when the application goes online. Users should still be allowed to browse and search for emails on the device even if they are offline.

Should emails between the same sender and topic be threaded?
Threading of message conversations will be good but not required.