Isolate Netlify, Firebase and Helper functions + Import from absolute paths

helpers/utils/contenttypes.js

@@ -0,0 +1,27 @@
+export const knownContentTypes = [
+  "application/json",
+  "application/vnd.api+json",
+  "application/hal+json",
+  "application/xml",
+  "application/x-www-form-urlencoded",
+  "text/html",
+  "text/plain",
+]
+
+export function isJSONContentType(contentType) {
+  if (contentType.includes(";")) {
+    const [justContentType] = contentType.split(";")
+
+    return (
+      justContentType === "application/json" ||
+      justContentType === "application/vnd.api+json" ||
+      justContentType === "application/hal+json"
+    )
+  } else {
+    return (
+      contentType === "application/json" ||
+      contentType === "application/vnd.api+json" ||
+      contentType === "application/hal+json"
+    )
+  }
+}

helpers/utils/debounce.js

@@ -0,0 +1,15 @@
+// Debounce is a higher order function which makes its enclosed function be executed
+// only if the function wasn't called again till 'delay' time has passed, this helps reduce impact of heavy working
+// functions which might be called frequently
+// NOTE : Don't use lambda functions as this doesn't get bound properly in them, use the 'function (args) {}' format
+const debounce = (func, delay) => {
+  let inDebounce
+  return function () {
+    const context = this
+    const args = arguments
+    clearTimeout(inDebounce)
+    inDebounce = setTimeout(() => func.apply(context, args), delay)
+  }
+}
+
+export default debounce

helpers/utils/string.js

@@ -0,0 +1,12 @@
+export function getSourcePrefix(source) {
+  const sourceEmojis = {
+    // Source used for info messages.
+    info: "\tℹ️ [INFO]:\t",
+    // Source used for client to server messages.
+    client: "\t👽 [SENT]:\t",
+    // Source used for server to client messages.
+    server: "\t📥 [RECEIVED]:\t",
+  }
+  if (Object.keys(sourceEmojis).includes(source)) return sourceEmojis[source]
+  return ""
+}

helpers/utils/uri.js

@@ -0,0 +1,13 @@
+export function parseUrlAndPath(value) {
+  let result = {}
+  try {
+    let url = new URL(value)
+    result.url = url.origin
+    result.path = url.pathname
+  } catch (error) {
+    let uriRegex = value.match(/^((http[s]?:\/\/)?(<<[^\/]+>>)?[^\/]*|)(\/?.*)$/)
+    result.url = uriRegex[1]
+    result.path = uriRegex[4]
+  }
+  return result
+}

helpers/utils/valid.js

@@ -0,0 +1,37 @@
+const [wsRegexIP, wsRegexHostname] = generateREForProtocol("^(wss?:\\/\\/)?")
+const [sseRegexIP, sseRegexHostname] = generateREForProtocol("^(https?:\\/\\/)?")
+const [socketioRegexIP, socketioRegexHostname] = generateREForProtocol(
+  "^((wss?:\\/\\/)|(https?:\\/\\/))?"
+)
+
+function generateREForProtocol(protocol) {
+  return [
+    new RegExp(
+      `${protocol}(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$`
+    ),
+    new RegExp(
+      `${protocol}(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]).)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9/])$`
+    ),
+  ]
+}
+
+/**
+ * valid url for ws/wss
+ */
+export function wsValid(url) {
+  return wsRegexIP.test(url) || wsRegexHostname.test(url)
+}
+
+/**
+ * valid url for http/https
+ */
+export function httpValid(url) {
+  return sseRegexIP.test(url) || sseRegexHostname.test(url)
+}
+
+/**
+ * valid url for ws/wss/http/https
+ */
+export function socketioValid(url) {
+  return socketioRegexIP.test(url) || socketioRegexHostname.test(url)
+}