@wikicasa-dev/utilities 0.1.1 → 0.1.2

package/src/utils/MapUtils.ts

@@ -0,0 +1,118 @@
+import type { LatLng } from "leaflet";
+import { encode } from "google-polyline";
+
+import Leaflet_map from "../custom/leaflet_map";
+
+declare global {
+  interface Window {
+    _mapRange?: number;
+  }
+}
+
+export function parsePoints(polygonFromMap: string): Array<LatLng> | undefined {
+  if (!polygonFromMap) return;
+
+  const numbers: RegExpMatchArray | null =
+    polygonFromMap.match(/[-]?[\d]*[.]?[\d]+/g);
+
+  if (!numbers) return;
+
+  const latLngs: Array<LatLng> = [];
+
+  for (let i = 0; i < numbers.length; i++) {
+    latLngs.push({
+      lat: parseFloat(numbers[i + 1]),
+      lng: parseFloat(numbers[i]),
+    } as LatLng);
+    i++;
+  }
+
+  return latLngs;
+}
+
+/**
+ * @param polygon An array of latitude and polygon that will be used to design an area in a map
+ * @param forUrl If true, the output string will be encoded as a URI so respecting the UTF-8 encoding
+ * */
+export function encodePolygon(polygon: Array<LatLng>, forUrl = true): string {
+  const polygonArr: Array<any> = [];
+  polygon.forEach((p: LatLng) => {
+    polygonArr.push([p.lat, p.lng]);
+  });
+  const encodedPolygon = encode(polygonArr);
+  return forUrl ? encodeURIComponent(encodedPolygon) : encodedPolygon;
+}
+
+export function getMinMaxLatLng(polygon: Array<LatLng>): {
+  miny: number;
+  maxy: number;
+  minx: number;
+  maxx: number;
+} {
+  const minmax = {
+    miny: polygon[0].lat,
+    maxy: polygon[0].lat,
+    minx: polygon[0].lng,
+    maxx: polygon[0].lng,
+  };
+  polygon.forEach((p: LatLng) => {
+    minmax.miny = Math.min(minmax.miny, p.lat);
+    minmax.maxy = Math.max(minmax.maxy, p.lat);
+    minmax.minx = Math.min(minmax.minx, p.lng);
+    minmax.maxx = Math.max(minmax.maxx, p.lng);
+  });
+  return minmax;
+}
+
+export function removeDuplicatePoints(latLngs: Array<LatLng>): Array<LatLng> {
+  if (latLngs.length <= 0) return [];
+
+  const uniqueCoordinates = new Set();
+  const unique = latLngs.filter((x) => {
+    const isDuplicate = uniqueCoordinates.has(x.lat + x.lng);
+    const coordinate = x.lat + x.lng;
+    uniqueCoordinates.add(coordinate);
+    return !isDuplicate;
+  });
+
+  return unique;
+}
+
+export function calcPolygonCenter(points: Array<LatLng>): LatLng {
+  let lat = 0;
+  let lng = 0;
+
+  for (let i = 0; i < points.length; i++) {
+    const point = points[i];
+
+    lat += point.lat;
+    lng += point.lng;
+  }
+
+  return { lat: lat / points.length, lng: lng / points.length } as LatLng;
+}
+
+export function validateMap(map: Leaflet_map): boolean {
+  const mapRange = window._mapRange || 10000;
+
+  if (map) {
+    const center = map.getShape()?.getCenter();
+    const points = map.getShapePoints();
+    if (points) {
+      for (let i = 0; i < points.length; i++) {
+        if (map.getDistance(points[i], center) > mapRange) return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+export function getPolygonString(shapePoints: Array<LatLng>): string {
+  let polygonString = "POLYGON((";
+  shapePoints.forEach((point: LatLng) => {
+    polygonString += `${point.lng} ${point.lat}, `;
+  });
+  polygonString += `${shapePoints[0].lng} ${shapePoints[0].lat}))`;
+  return polygonString;
+}

package/src/utils/NumberUtils.ts

@@ -0,0 +1,90 @@
+/**
+ * Parse a localized number to a float.
+ * @param stringNumber - the localized number
+ * @param locale - [optional] the locale that the number is represented in. Omit this parameter to use the current locale.
+ */
+export const parseLocaleNumber = (
+  stringNumber: string | number,
+  locale?: string
+): number | string => {
+  if (!locale) locale = navigator.language;
+
+  const thousandSeparator = Intl.NumberFormat(locale)
+    .format(1111)
+    .replace(/\p{Number}/gu, "");
+  const decimalSeparator = Intl.NumberFormat(locale)
+    .format(1.1)
+    .replace(/\p{Number}/gu, "");
+  const parsedNumber = parseFloat(
+    `${stringNumber}`
+      .replace(new RegExp("\\" + thousandSeparator, "g"), "")
+      .replace(new RegExp("\\" + decimalSeparator), ".")
+  );
+
+  /* In case the parsed number is NaN, we will return an empty string! */
+  if (isNaN(parsedNumber)) return "";
+
+  return parsedNumber;
+};
+
+export const formatLocaleNumber = (
+  numberToFormat?: number | string,
+  props?: { currency: boolean }
+): string | undefined | null => {
+  if (numberToFormat === undefined || numberToFormat === null) return;
+
+  numberToFormat = parseFloat(`${numberToFormat}`);
+
+  /* If the number to format is NaN, we won't return anything */
+  if (isNaN(numberToFormat)) return "";
+
+  const currencyOptions = {
+    style: "currency",
+    currency: "EUR",
+  };
+  const defaultOptions = {
+    maximumFractionDigits: 0,
+  };
+  let options = { ...defaultOptions };
+  if (props?.currency) options = { ...options, ...currencyOptions };
+
+  return new Intl.NumberFormat(navigator.language, {
+    ...options,
+  }).format(numberToFormat);
+};
+
+export function formatInteger(
+  value: number | undefined,
+  round: boolean = false
+): string {
+  if (value == null) return "";
+
+  return formatNumber(round ? Math.round(value) : Math.floor(value), 0);
+}
+
+export function formatNumber(
+  value: number | undefined,
+  digits?: number
+): string {
+  if (!value && value !== 0) return "";
+
+  return value.toLocaleString(
+    "it-IT", // usare una stringa tipo 'en-US' per sovrascrivere la lingua del browser
+    {
+      minimumFractionDigits: digits,
+      maximumFractionDigits: digits,
+    }
+  );
+}
+
+export function formatFloat(
+  value: number | undefined,
+  digits: number = 2
+): string {
+  return formatNumber(value, digits);
+}
+
+export const formatterNumberObj = {
+  formatFn: formatLocaleNumber,
+  unFormatFn: parseLocaleNumber,
+};

package/src/utils/ObjectUtils.ts

@@ -0,0 +1,34 @@
+export function shallowCopyObjectTo(
+  from: Record<string, any> | undefined,
+  to: Record<string, any>
+): void {
+  if (!from) return;
+
+  for (const k in from) {
+    to[k] = from[k];
+  }
+}
+
+export function isEmptyObject(obj: any): boolean {
+  return !obj || !Object.keys(obj).length;
+}
+
+/**
+ * Makes the deep copy of the input object.
+ * For performance purposes, if the values of the properties of the object to copy are all primitive types then we will use the spread operator (faster).
+ * Otherwise, to ensure the deep copy of nested objects and arrays, we will use JSON.parse and JSON.stringify (slower).
+ * */
+export function deepCopy<T>(objToCopy: T): T | null {
+  if (!objToCopy) return null;
+
+  for (const key in objToCopy) {
+    const prop = objToCopy[key];
+    if (!prop) continue;
+
+    //Sebastian R.S: If the property value is a primitive type, then we will continue!
+    if (Array.isArray(prop) || Object.keys(prop).length > 0) {
+      return JSON.parse(JSON.stringify(objToCopy));
+    }
+  }
+  return { ...objToCopy };
+}

package/src/utils/ObserverUtils.ts

@@ -0,0 +1,32 @@
+/**
+ * Observes if an element is visible in the viewport. Once it is visible, the listener is removed
+ * */
+export function observeOnce(
+  selector: string,
+  fn: (Element: Node, IntersectionObserver: IntersectionObserver) => void,
+  options?: IntersectionObserverInit
+): void {
+  const elems = [].slice.call(document.querySelectorAll(selector));
+
+  const observer = new IntersectionObserver(
+    (
+      entries: Array<IntersectionObserverEntry>,
+      observer: IntersectionObserver
+    ) => {
+      for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+
+        if (entry.isIntersecting) {
+          const elem = entry.target;
+          fn(elem, observer);
+          observer.unobserve(elem);
+        }
+      }
+    },
+    options
+  );
+
+  elems.forEach((elem: HTMLElement) => {
+    observer.observe(elem);
+  });
+}

package/src/utils/PermissionUtils.ts

@@ -0,0 +1,41 @@
+export type PermissionStates = "granted" | "denied" | "prompt";
+export type PermissionChangeEvent = CustomEvent<{
+  permissionState: PermissionStates;
+}>;
+export type NotificationPermissionChangeHandler = (
+  e: PermissionChangeEvent
+) => void | Promise<void>;
+
+let permissionsListenerInit = false;
+
+export const onNotificationsPermissionChange = (
+  cb: NotificationPermissionChangeHandler
+): void => {
+  // @ts-ignore
+  document.addEventListener("notification-permission-changed", cb);
+};
+
+/**
+ * Add an event listener which emits the event "notification-permission-changed" when the user changes the state of the notifications
+ * */
+export const addPermissionStateListener = (): void => {
+  if (!navigator.permissions || !navigator.permissions.query) return;
+
+  //setting the listener ONCE
+  !permissionsListenerInit &&
+    navigator.permissions
+      .query({ name: "notifications" })
+      .then(function (permission) {
+        // Initial status is available at permission.state
+        permission.onchange = function (): void {
+          // Whenever there's a change, updated status is available at this.state
+          document.dispatchEvent(
+            new CustomEvent("notification-permission-changed", {
+              detail: { permissionState: this.state },
+            })
+          );
+        };
+      });
+
+  permissionsListenerInit = true;
+};

package/src/utils/RESB_UrlBuilder.ts

@@ -0,0 +1,99 @@
+import type { RealEstateSearchBean } from "@wikicasa-dev/types";
+
+import {
+  CONTRACT,
+  searchBeanMap,
+  searchBeanMapAgencyFilter,
+} from "@wikicasa-dev/types";
+
+declare global {
+  interface Window {
+    _auctionLabel: string;
+    _rentLabel: string;
+    _saleLabel: string;
+  }
+}
+
+export function buildURL(
+  cityURL: string,
+  listingTypology: string,
+  contractType: number | undefined | null,
+  zone?: string | null,
+  seoFilter?: string | null,
+  agencyAndPlace?: string,
+  district?: string | null
+): string {
+  let URL = "/";
+
+  if (contractType) {
+    URL +=
+      (contractType == CONTRACT.AUCTION
+        ? window["_auctionLabel"]
+        : contractType == CONTRACT.RENT
+        ? window["_rentLabel"]
+        : window["_saleLabel"]) + "-";
+  }
+
+  URL += `${listingTypology}/`;
+
+  if (agencyAndPlace) URL += `${agencyAndPlace}/`;
+
+  if (cityURL) URL += `${cityURL.replace(/^-+|-+$/g, "")}/`;
+
+  if (zone) {
+    URL += `${zone.replace(/^_+|_+$/g, "")}/`;
+  }
+
+  if (!zone && district) {
+    URL += `${district.replace(/^_+|_+$/g, "")}/`;
+  }
+
+  if (seoFilter) {
+    URL += `${seoFilter.replace(/^_+|_+$/g, "")}/`;
+  }
+  return URL;
+}
+
+export function buildParams(searchBean: RealEstateSearchBean): string {
+  const params = Object.keys(searchBeanMap)
+    .map((key) => {
+      if (searchBean[key]) {
+        return (
+          encodeURIComponent(searchBeanMap[key]) +
+          "=" +
+          encodeURIComponent(searchBean[key])
+        );
+      } else return null;
+    })
+    .filter((param) => param !== null);
+
+  return params.length ? `?${params.join("&")}` : "";
+}
+
+export function buildParamsForAgency(searchBean: RealEstateSearchBean): string {
+  const params = Object.keys(searchBeanMapAgencyFilter)
+    .map((key) => {
+      if (searchBean[key]) {
+        if (Array.isArray(searchBean[key])) {
+          const arr = searchBean[key];
+          const nameField = searchBeanMapAgencyFilter[key];
+          let strToReturn = "";
+          for (let i = 0; i < arr.length; i++) {
+            strToReturn +=
+              encodeURIComponent(nameField) + "=" + encodeURIComponent(arr[i]);
+            strToReturn += i < arr.length - 1 ? "&" : "";
+          }
+          return strToReturn;
+        } else {
+          return (
+            encodeURIComponent(searchBeanMapAgencyFilter[key]) +
+            "=" +
+            encodeURIComponent(searchBean[key])
+          );
+        }
+      } else return null;
+    })
+    .filter((param) => param !== null);
+
+  return params.length ? `?${params.join("&")}` : "";
+}

package/src/utils/RequestUtils.ts

@@ -0,0 +1,20 @@
+import axios from "axios";
+
+import type { RequestGeneric } from "@wikicasa-dev/types";
+
+export function sendRequestGeneric(rg: RequestGeneric): Promise<unknown> {
+  return new Promise(
+    (
+      resolve: (...args: Array<unknown>) => void,
+      reject: (error: Error) => void
+    ) =>
+      axios
+        .post("/rest/request/addRequestGenericValuation", rg, {
+          headers: { "Content-Type": "application/json", dataType: "json" },
+        })
+        .then(() => {
+          resolve();
+        })
+        .catch((error: any) => reject(error))
+  );
+}

package/src/utils/StringUtils.ts

@@ -0,0 +1,67 @@
+export function replaceAll(str: string, find: string, replace: string): string {
+  return str.replace(new RegExp(find, "g"), replace);
+}
+
+export function capitalizeFirstLetter(string: string): string {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+export function formatAddress(
+  streetName: string,
+  streetNumber: string,
+  cityName: string,
+  provinceAcronym?: string
+): string {
+  const components: Array<string> = [];
+
+  if (streetName && streetName !== "ND") {
+    if (streetNumber && streetNumber !== "ND" && streetNumber !== "0")
+      components.push(`${streetName} ${streetNumber}`);
+    else components.push(streetName);
+  }
+
+  if (cityName && provinceAcronym) {
+    components.push(`${cityName} (${provinceAcronym})`);
+  } else {
+    components.push(cityName);
+  }
+
+  const address = components
+    .filter((component: string) => !!component)
+    .join(", ");
+
+  return capitalizeFirstLetter(address);
+}
+
+export function decodeTextWithEntities(strWithEntities: string | null): string {
+  if (!strWithEntities) return "";
+
+  const a = document.createElement("span");
+  a.innerHTML = strWithEntities;
+  return a.textContent || "";
+}
+
+/**
+ * Replaces a given string with the values of the object
+ * @param str string to replace
+ * @param mapObj Object whose keys are the tokens to replace and whose values are the ones that will replace that matched token
+ * e.g. replaceAllToken('Here we go', {Here: Now, go: eat}) returns 'Now we eat'
+ * */
+export function replaceAllTokens(
+  str: string,
+  mapObj: Record<string, string>
+): string {
+  const re = new RegExp(
+    Object.keys(mapObj)
+      .map((key) => key.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"))
+      .join("|"),
+    "gi"
+  );
+  return str.replace(re, function (matched) {
+    return mapObj[matched.toLowerCase()];
+  });
+}
+
+export function cleanASCII(str: string): string {
+  return str.replace(/[\uA78C\uA78B]/g, "'").replace(/[^\x00-\x7F]/g, "");
+}

package/src/utils/URLBuilderUtils.ts

@@ -0,0 +1,21 @@
+/**
+ * <p>Adds a query string to the provided URL using the params object</p>
+ * <p>e.g. Input => URL: www.sample.com, params = {userId: 56, name: "Jonas"}</p>
+ *      Output => www.sample.com?userId=56&name=Jonas
+ * @param url The url that will contain the query string
+ * @param params The object that will be transformed into a query string
+ * @return A new url instance containing the query string
+ * */
+export const appendQueryString = (
+  url: URL,
+  params: Record<string, any> = {}
+): URL => {
+  if (Object.keys(params).length === 0)
+    throw "The params object can't be empty";
+
+  const urlWithQueryString = new URL(url);
+  for (const key in params)
+    urlWithQueryString.searchParams.append(key, `${params[key]}`);
+
+  return urlWithQueryString;
+};

package/src/utils/URLPagesFactory.ts

@@ -0,0 +1,20 @@
+import type { PAGES } from "@wikicasa-dev/types";
+
+declare global {
+  interface Window {
+    _baseURL: string;
+    _privateURL: string;
+    _saveSearchesURL: string;
+  }
+}
+
+export const getURLPage = (page: PAGES): string => {
+  const baseUrl = `${window["_baseURL"]}`;
+
+  switch (page) {
+    case "SAVED_SEARCHES":
+      return `${baseUrl}/${window["_privateURL"]}/${window["_saveSearchesURL"]}`;
+    default:
+      throw new Error(`There is no matching URL for ${page}`);
+  }
+};

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "baseUrl": "src",
+    "outDir": "./dist",
+    "declaration": true,
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "paths": {
+      "@utils/*": ["./utils/*"],
+      "@services/*": ["./services/*"]
+    },
+
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "noImplicitReturns": true,
+    "forceConsistentCasingInFileNames": true,
+
+    /* Bundler mode */
+    "moduleResolution": "Node",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+
+    "strictPropertyInitialization": false
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}

package/vite.config.ts

@@ -0,0 +1,42 @@
+// vite.config.ts
+import { fileURLToPath, URL } from "url";
+import { resolve } from "path";
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+
+const getPackageName = () => {
+  return "utilities";
+};
+
+const fileName = {
+  es: `${getPackageName()}.mjs`,
+  cjs: `${getPackageName()}.cjs`,
+  iife: `${getPackageName()}.iife.js`,
+};
+
+const formats = Object.keys(fileName) as Array<keyof typeof fileName>;
+
+// https://vitejs.dev/guide/build.html#library-mode
+export default defineConfig({
+  build: {
+    lib: {
+      entry: resolve(__dirname, "src/index.ts"),
+      name: getPackageName(),
+      formats,
+      fileName: (format) => fileName[format],
+    },
+  },
+  resolve: {
+    alias: [
+      {
+        find: "@utils",
+        replacement: fileURLToPath(new URL("./src/utils", import.meta.url)),
+      },
+      {
+        find: "@services",
+        replacement: fileURLToPath(new URL("./src/services", import.meta.url)),
+      },
+    ],
+  },
+  plugins: [dts()],
+});