@inzombieland/core 0.0.1 → 1.18.0

package/helpers/api-helper.mjs

@@ -0,0 +1,99 @@
+import { dateHelper } from "./date-helper.mjs";
+const isoExp = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)((-(\d{2}):(\d{2})|Z)?)$/gm;
+const isISODate = (value) => {
+  return typeof value === "string" && isoExp.test(value);
+};
+const isDate = (value) => {
+  return value instanceof Date;
+};
+const isObject = (value) => {
+  return typeof value === "object" && value !== null && value.constructor === Object;
+};
+const hasOwnProp = {}.hasOwnProperty;
+export function convertToClient(data) {
+  if (!isObject(data) && !Array.isArray(data)) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => {
+      if (isObject(item)) {
+        return convertToClient(item);
+      }
+      return item;
+    });
+  }
+  const res = {};
+  const objectData = data;
+  for (const key in objectData) {
+    if (!hasOwnProp.call(objectData, key)) {
+      return;
+    }
+    const value = objectData[key];
+    const newKey = key === key.toUpperCase() ? key.toLowerCase() : key.slice(0, 1).toLowerCase() + key.slice(1);
+    if (Array.isArray(value)) {
+      res[newKey] = value.map((item) => {
+        if (isObject(item)) {
+          return convertToClient(item);
+        }
+        return item;
+      });
+    } else if (isObject(value)) {
+      res[newKey] = convertToClient(value);
+    } else if (isISODate(value)) {
+      res[newKey] = dateHelper.stringToDate(value);
+    } else if (value === null) {
+      delete res[newKey];
+    } else {
+      res[newKey] = value;
+    }
+  }
+  return res;
+}
+export function convertToServer(data) {
+  if (typeof data === "string") {
+    data = parseData(data);
+  }
+  if (!isObject(data) && !Array.isArray(data)) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => {
+      if (isObject(item)) {
+        return convertToServer(item);
+      }
+      return item;
+    });
+  }
+  const res = {};
+  const objectData = data;
+  for (const key in objectData) {
+    if (!hasOwnProp.call(objectData, key)) {
+      return;
+    }
+    const value = objectData[key];
+    const newKey = key.slice(0, 1).toUpperCase() + key.slice(1);
+    if (Array.isArray(value)) {
+      res[newKey] = value.map((item) => {
+        if (isObject(item)) {
+          return convertToServer(item);
+        }
+        return item;
+      });
+    } else if (isObject(value)) {
+      res[newKey] = convertToServer(value);
+    } else if (isDate(value)) {
+      res[newKey] = dateHelper.dateFormat(value, "isoDateTime");
+    } else {
+      res[newKey] = value;
+    }
+  }
+  return res;
+}
+function parseData(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
+export const apiHelper = { convertToClient, convertToServer };

package/helpers/current-device.d.ts

@@ -0,0 +1,67 @@
+export namespace device {
+    function macos(): any;
+    function ios(): any;
+    function iphone(): any;
+    function ipod(): any;
+    function ipad(): any;
+    function android(): any;
+    function androidPhone(): any;
+    function androidTablet(): any;
+    function blackberry(): any;
+    function blackberryPhone(): any;
+    function blackberryTablet(): any;
+    function windows(): any;
+    function windowsPhone(): any;
+    function windowsTablet(): any;
+    function fxos(): any;
+    function fxosPhone(): any;
+    function fxosTablet(): any;
+    function meego(): any;
+    function cordova(): any;
+    function mobile(): any;
+    function tablet(): any;
+    function desktop(): boolean;
+    function television(): boolean;
+    function portrait(): any;
+    function landscape(): any;
+    function noConflict(): {
+        macos(): any;
+        ios(): any;
+        iphone(): any;
+        ipod(): any;
+        ipad(): any;
+        android(): any;
+        androidPhone(): any;
+        androidTablet(): any;
+        blackberry(): any;
+        blackberryPhone(): any;
+        blackberryTablet(): any;
+        windows(): any;
+        windowsPhone(): any;
+        windowsTablet(): any;
+        fxos(): any;
+        fxosPhone(): any;
+        fxosTablet(): any;
+        meego(): any;
+        cordova(): any;
+        mobile(): any;
+        tablet(): any;
+        desktop(): boolean;
+        television(): boolean;
+        portrait(): any;
+        landscape(): any;
+        noConflict(): /*elided*/ any;
+        onChangeOrientation(cb: any): void;
+        linux(): any;
+        ubuntu(): any;
+        type: any;
+        os: any;
+        osName(): any;
+    };
+    function onChangeOrientation(cb: any): void;
+    function linux(): any;
+    function ubuntu(): any;
+    let type: any;
+    let os: any;
+    function osName(): any;
+}

package/helpers/current-device.mjs

@@ -0,0 +1,368 @@
+const device = {}
+
+// https://github.com/matthewhudson/current-device
+if (typeof window !== "undefined") {
+	// Public functions to get the current value of type, os, or orientation.
+	const findMatch = arr => {
+		for (const name of arr) {
+			if (device[name]()) {
+				return name
+			}
+		}
+		return "unknown"
+	}
+
+	const setOrientationCache = () => {
+		device.orientation = findMatch(["portrait", "landscape"])
+	}
+
+	const walkOnChangeOrientationList = newOrientation => {
+		for (const cb of changeOrientationList) {
+			cb(newOrientation)
+		}
+	}
+
+	// Check if documentElement already has a given class.
+	const hasClass = className => {
+		return documentElement.classList.contains(className)
+	}
+
+	// Add one or more CSS classes to the <html> element.
+	const addClass = className => {
+		let currentClassNames = null
+		if (!hasClass(className)) {
+			currentClassNames = documentElement.classList.toString().trim()
+			documentElement.className = `${currentClassNames} ${className}`
+		}
+	}
+
+	// Remove single CSS class from the <html> element.
+	const removeClass = className => {
+		if (hasClass(className)) {
+			documentElement.className = documentElement.className.replace(` ${className}`, "")
+		}
+	}
+
+	// Handle device orientation changes.
+	const handleOrientation = () => {
+		if (device.landscape()) {
+			removeClass("portrait")
+			addClass("landscape")
+			walkOnChangeOrientationList("landscape")
+		} else {
+			removeClass("landscape")
+			addClass("portrait")
+			walkOnChangeOrientationList("portrait")
+		}
+		setOrientationCache()
+	}
+
+	// Check if element exists.
+	const includes = (haystack, needle) => {
+		return haystack.includes(needle)
+	}
+
+	// Simple UA string search.
+	const find = needle => {
+		return includes(userAgent, needle)
+	}
+
+	// Save the previous value of the device variable.
+	const previousDevice = window.device
+
+	const changeOrientationList = []
+
+	// Add device as a global object.
+	window.device = device
+
+	// The <html> element.
+	const documentElement = window.document.documentElement
+
+	// The client user agent string.
+	// Lowercase, so we can use the more efficient indexOf(), instead of Regex
+	const userAgent = window.navigator.userAgent.toLowerCase()
+
+	// Detectable television devices.
+	const television = [
+		"googletv",
+		"viera",
+		"smarttv",
+		"internet.tv",
+		"netcast",
+		"nettv",
+		"appletv",
+		"boxee",
+		"kylo",
+		"roku",
+		"dlnadoc",
+		"pov_tv",
+		"hbbtv",
+		"ce-html",
+	]
+
+	// Main functions
+	// --------------
+
+	device.macos = function () {
+		return find("mac")
+	}
+
+	device.ios = function () {
+		return device.iphone() || device.ipod() || device.ipad()
+	}
+
+	device.iphone = function () {
+		return !device.windows() && find("iphone")
+	}
+
+	device.ipod = function () {
+		return find("ipod")
+	}
+
+	device.ipad = function () {
+		const iPadOS13Up = navigator.userAgent.includes("Mac") && navigator.maxTouchPoints > 1
+		return find("ipad") || iPadOS13Up
+	}
+
+	device.android = function () {
+		return !device.windows() && find("android")
+	}
+
+	device.androidPhone = function () {
+		return device.android() && find("mobile")
+	}
+
+	device.androidTablet = function () {
+		return device.android() && !find("mobile")
+	}
+
+	device.blackberry = function () {
+		return find("blackberry") || find("bb10")
+	}
+
+	device.blackberryPhone = function () {
+		return device.blackberry() && !find("tablet")
+	}
+
+	device.blackberryTablet = function () {
+		return device.blackberry() && find("tablet")
+	}
+
+	device.windows = function () {
+		return find("windows")
+	}
+
+	device.windowsPhone = function () {
+		return device.windows() && find("phone")
+	}
+
+	device.windowsTablet = function () {
+		return device.windows() && find("touch") && !device.windowsPhone()
+	}
+
+	device.fxos = function () {
+		return (find("(mobile") || find("(tablet")) && find(" rv:")
+	}
+
+	device.fxosPhone = function () {
+		return device.fxos() && find("mobile")
+	}
+
+	device.fxosTablet = function () {
+		return device.fxos() && find("tablet")
+	}
+
+	device.meego = function () {
+		return find("meego")
+	}
+
+	device.cordova = function () {
+		return window.cordova && location.protocol === "file:"
+	}
+
+	device.mobile = function () {
+		return (
+			device.androidPhone() ||
+			device.iphone() ||
+			device.ipod() ||
+			device.windowsPhone() ||
+			device.blackberryPhone() ||
+			device.fxosPhone() ||
+			device.meego()
+		)
+	}
+
+	device.tablet = function () {
+		return (
+			device.ipad() ||
+			device.androidTablet() ||
+			device.blackberryTablet() ||
+			device.windowsTablet() ||
+			device.fxosTablet()
+		)
+	}
+
+	device.desktop = function () {
+		return !device.tablet() && !device.mobile()
+	}
+
+	device.television = function () {
+		let i = 0
+		while (i < television.length) {
+			if (find(television[i])) {
+				return true
+			}
+			i++
+		}
+		return false
+	}
+
+	device.portrait = function () {
+		if (screen.orientation) {
+			return includes(screen.orientation.type, "portrait")
+		}
+		return window.innerHeight / window.innerWidth > 1
+	}
+
+	device.landscape = function () {
+		if (screen.orientation) {
+			return includes(screen.orientation.type, "landscape")
+		}
+		return window.innerHeight / window.innerWidth < 1
+	}
+
+	// Public Utility Functions
+	// ------------------------
+
+	// Run device.js in noConflict mode,
+	// returning the device variable to its previous owner.
+	device.noConflict = function () {
+		window.device = previousDevice
+		return this
+	}
+
+	// Insert the appropriate CSS class based on the _user_agent.
+	if (device.ios()) {
+		if (device.ipad()) {
+			addClass("ios ipad tablet")
+		} else if (device.iphone()) {
+			addClass("ios iphone mobile")
+		} else if (device.ipod()) {
+			addClass("ios ipod mobile")
+		}
+	} else if (device.macos()) {
+		addClass("macos desktop")
+	} else if (device.android()) {
+		if (device.androidTablet()) {
+			addClass("android tablet")
+		} else {
+			addClass("android mobile")
+		}
+	} else if (device.blackberry()) {
+		if (device.blackberryTablet()) {
+			addClass("blackberry tablet")
+		} else {
+			addClass("blackberry mobile")
+		}
+	} else if (device.windows()) {
+		if (device.windowsTablet()) {
+			addClass("windows tablet")
+		} else if (device.windowsPhone()) {
+			addClass("windows mobile")
+		} else {
+			addClass("windows desktop")
+		}
+	} else if (device.fxos()) {
+		if (device.fxosTablet()) {
+			addClass("fxos tablet")
+		} else {
+			addClass("fxos mobile")
+		}
+	} else if (device.meego()) {
+		addClass("meego mobile")
+	} else if (device.television()) {
+		addClass("television")
+	} else if (device.desktop()) {
+		addClass("desktop")
+	}
+
+	if (device.cordova()) {
+		addClass("cordova")
+	}
+
+	device.onChangeOrientation = function (cb) {
+		if (typeof cb == "function") {
+			changeOrientationList.push(cb)
+		}
+	}
+
+	// Listen for changes in orientation.
+	if (screen?.orientation?.addEventListener) {
+		screen.orientation.addEventListener("change", handleOrientation, false)
+	}
+
+	handleOrientation()
+
+	device.linux = function () {
+		return find("linux")
+	}
+
+	device.ubuntu = function () {
+		return device.linux() && find("ubuntu")
+	}
+
+	device.type = findMatch(["mobile", "tablet", "desktop"])
+
+	device.os = findMatch([
+		"iphone",
+		"ipad",
+		"ipod",
+		"ios",
+		"android",
+		"blackberry",
+		"macos",
+		"windows",
+		"ubuntu",
+		"linux",
+		"fxos",
+		"meego",
+		"television",
+	])
+
+	device.osName = function () {
+		switch (device.os) {
+			case "iphone":
+				return "iPhone"
+			case "ipad":
+				return "iPad"
+			case "ipod":
+				return "iPod"
+			case "ios":
+				return "iOS"
+			case "android":
+				return "Android"
+			case "blackberry":
+				return "BlackBerry"
+			case "macos":
+				return "Mac OS"
+			case "windows":
+				return "Windows"
+			case "ubuntu":
+				return "Ubuntu Linux"
+			case "linux":
+				return "Linux"
+			case "fxos":
+				return "FXOS"
+			case "meego":
+				return "MeeGo"
+			case "television":
+				return "Television"
+			default:
+				return device.os
+		}
+	}
+
+	setOrientationCache()
+}
+
+export { device }

package/helpers/date-helper.d.ts

@@ -0,0 +1,15 @@
+export declare function stringToDate(dateString: unknown): Date | undefined;
+/**
+ * Преобразование даты.
+ * Например из "d mmmm:R yyyy" в "5 февраля 2020"
+ * @param date - дата
+ * @param format - формат даты
+ * @param locale
+ * @param dateTimeNow
+ */
+export declare function dateFormat(// @SONAR_STOP@
+date?: Date, format?: string, locale?: string, dateTimeNow?: Date): string;
+export declare const dateHelper: {
+    stringToDate: typeof stringToDate;
+    dateFormat: typeof dateFormat;
+};