Merge branch 'Expensify:main' into fix/update-order

lib/Logger.ts

@@ -0,0 +1,31 @@
+type LogData = {
+    message: string;
+    level: 'alert' | 'info';
+};
+type LoggerCallback = (data: LogData) => void;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+let logger: LoggerCallback = () => {};
+
+/**
+ * Register the logging callback
+ */
+function registerLogger(callback: LoggerCallback) {
+    logger = callback;
+}
+
+/**
+ * Send an alert message to the logger
+ */
+function logAlert(message: string) {
+    logger({message: `[Onyx] ${message}`, level: 'alert'});
+}
+
+/**
+ * Send an info message to the logger
+ */
+function logInfo(message: string) {
+    logger({message: `[Onyx] ${message}`, level: 'info'});
+}
+
+export {registerLogger, logInfo, logAlert};

lib/Str.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns true if the haystack begins with the needle
+ *
+ * @param haystack  The full string to be searched
+ * @param needle    The case-sensitive string to search for
+ * @return Returns true if the haystack starts with the needle.
+ */
+function startsWith(haystack: string, needle: string) {
+    return typeof haystack === 'string' && typeof needle === 'string' && haystack.startsWith(needle);
+}
+
+/**
+ * Checks if parameter is a string or function.
+ * If it is a string, then we will just return it.
+ * If it is a function, then we will call it with
+ * any additional arguments and return the result.
+ */
+function result(parameter: string): string;
+function result<TFunction extends (...a: TArgs) => unknown, TArgs extends unknown[]>(parameter: TFunction, ...args: TArgs): ReturnType<TFunction>;
+function result<TFunction extends (...a: TArgs) => unknown, TArgs extends unknown[]>(parameter: TFunction, ...args: TArgs): ReturnType<TFunction> | string {
+    return typeof parameter === 'function' ? (parameter(...args) as ReturnType<TFunction>) : parameter;
+}
+
+export {startsWith, result};

lib/createDeferredTask.js → lib/createDeferredTask.ts

@@ -1,13 +1,16 @@
+type DeferredTask = {
+    promise: Promise<void>;
+    resolve?: () => void;
+};
+
 /**
  * Create a deferred task that can be resolved when we call `resolve()`
  * The returned promise will complete when we call `resolve`
  * Useful when we want to wait for a tasks that is resolved from an external action
- *
- * @template T
- * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
-export default function createDeferredTask() {
-    const deferred = {};
+export default function createDeferredTask(): DeferredTask {
+    const deferred = {} as DeferredTask;
+
     deferred.promise = new Promise((res) => {
         deferred.resolve = res;
     });

lib/storage/__mocks__/index.ts

@@ -10,6 +10,7 @@ const set = jest.fn((key, value) => {
 });
 
 const idbKeyvalMock: StorageProvider = {
+    name: 'KeyValMockProvider',
     init: () => undefined,
     setItem(key, value) {
         return set(key, value);