From 291803c31f829fe0d32bb3207bc11def95a7408c Mon Sep 17 00:00:00 2001
From: Nevena Bojovic <nenabojov@gmail.com>
Date: Tue, 1 Mar 2022 20:05:50 +0100
Subject: Urađena test aplikacija. Povezan front i back.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Front/node_modules/run-async/index.js          | 98 ++++++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 sandbox/testAppNevena/Front/node_modules/run-async/index.js

(limited to 'sandbox/testAppNevena/Front/node_modules/run-async/index.js')

diff --git a/sandbox/testAppNevena/Front/node_modules/run-async/index.js b/sandbox/testAppNevena/Front/node_modules/run-async/index.js
new file mode 100644
index 00000000..c7a2e65d
--- /dev/null
+++ b/sandbox/testAppNevena/Front/node_modules/run-async/index.js
@@ -0,0 +1,98 @@
+'use strict';
+
+function isPromise(obj) {
+  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+}
+
+/**
+ * Return a function that will run a function asynchronously or synchronously
+ *
+ * example:
+ * runAsync(wrappedFunction, callback)(...args);
+ *
+ * @param   {Function} func  Function to run
+ * @param   {Function} cb    Callback function passed the `func` returned value
+ * @return  {Function(arguments)} Arguments to pass to `func`. This function will in turn
+ *                                return a Promise (Node >= 0.12) or call the callbacks.
+ */
+
+var runAsync = module.exports = function (func, cb) {
+  cb = cb || function () {};
+
+  return function () {
+
+    var args = arguments;
+
+    var promise = new Promise(function (resolve, reject) {
+      var resolved = false;
+      const wrappedResolve = function (value) {
+        if (resolved) {
+          console.warn('Run-async promise already resolved.')
+        }
+        resolved = true;
+        resolve(value);
+      }
+
+      var rejected = false;
+      const wrappedReject = function (value) {
+        if (rejected) {
+          console.warn('Run-async promise already rejected.')
+        }
+        rejected = true;
+        reject(value);
+      }
+
+      var usingCallback = false;
+      var callbackConflict = false;
+      var contextEnded = false;
+
+      var answer = func.apply({
+        async: function () {
+          if (contextEnded) {
+            console.warn('Run-async async() called outside a valid run-async context, callback will be ignored.');
+            return function() {};
+          }
+          if (callbackConflict) {
+            console.warn('Run-async wrapped function (async) returned a promise.\nCalls to async() callback can have unexpected results.');
+          }
+          usingCallback = true;
+          return function (err, value) {
+            if (err) {
+              wrappedReject(err);
+            } else {
+              wrappedResolve(value);
+            }
+          };
+        }
+      }, Array.prototype.slice.call(args));
+
+      if (usingCallback) {
+        if (isPromise(answer)) {
+          console.warn('Run-async wrapped function (sync) returned a promise but async() callback must be executed to resolve.');
+        }
+      } else {
+        if (isPromise(answer)) {
+          callbackConflict = true;
+          answer.then(wrappedResolve, wrappedReject);
+        } else {
+          wrappedResolve(answer);
+        }
+      }
+      contextEnded = true;
+    });
+
+    promise.then(cb.bind(null, null), cb);
+
+    return promise;
+  }
+};
+
+runAsync.cb = function (func, cb) {
+  return runAsync(function () {
+    var args = Array.prototype.slice.call(arguments);
+    if (args.length === func.length - 1) {
+      args.push(this.async());
+    }
+    return func.apply(this, args);
+  }, cb);
+};
-- 
cgit v1.2.3