@formo/analytics 1.17.0 → 1.17.2

package/src/validators/address.ts

@@ -0,0 +1,69 @@
+import { isUint8Array, uint8ArrayToHexString } from "./uint8array";
+import { keccak256 } from "ethereum-cryptography/keccak.js";
+import { utf8ToBytes } from "ethereum-cryptography/utils.js";
+import { ValidInputTypes } from "../types";
+import { isHexStrict } from "./string";
+
+export const isAddress = (value: ValidInputTypes, checkChecksum = true) => {
+  if (typeof value !== "string" && !isUint8Array(value)) {
+    return false;
+  }
+
+  let valueToCheck: string;
+
+  if (isUint8Array(value)) {
+    valueToCheck = uint8ArrayToHexString(value);
+  } else if (typeof value === "string" && !isHexStrict(value)) {
+    valueToCheck = value.toLowerCase().startsWith("0x") ? value : `0x${value}`;
+  } else {
+    valueToCheck = value;
+  }
+
+  // check if it has the basic requirements of an address
+  if (!/^(0x)?[0-9a-f]{40}$/i.test(valueToCheck)) {
+    return false;
+  }
+  // If it's ALL lowercase or ALL upppercase
+  if (
+    /^(0x|0X)?[0-9a-f]{40}$/.test(valueToCheck) ||
+    /^(0x|0X)?[0-9A-F]{40}$/.test(valueToCheck)
+  ) {
+    return true;
+    // Otherwise check each case
+  }
+  return checkChecksum ? checkAddressCheckSum(valueToCheck) : true;
+};
+
+export const checkAddressCheckSum = (data: string): boolean => {
+  if (!/^(0x)?[0-9a-f]{40}$/i.test(data)) return false;
+  const address = data.slice(2);
+  const updatedData = utf8ToBytes(address.toLowerCase());
+
+  const addressHash = uint8ArrayToHexString(
+    keccak256(ensureIfUint8Array(updatedData))
+  ).slice(2);
+
+  for (let i = 0; i < 40; i += 1) {
+    // the nth letter should be uppercase if the nth digit of casemap is 1
+    if (
+      (parseInt(addressHash[i], 16) > 7 &&
+        address[i].toUpperCase() !== address[i]) ||
+      (parseInt(addressHash[i], 16) <= 7 &&
+        address[i].toLowerCase() !== address[i])
+    ) {
+      return false;
+    }
+  }
+  return true;
+};
+
+export function ensureIfUint8Array<T = any>(data: T) {
+  if (
+    !(data instanceof Uint8Array) &&
+    (data as { constructor: { name: string } })?.constructor?.name ===
+      "Uint8Array"
+  ) {
+    return Uint8Array.from(data as unknown as Uint8Array);
+  }
+  return data;
+}

package/src/validators/agent.ts

@@ -0,0 +1,4 @@
+export const isLocalhost = () =>
+  /^localhost$|^127(?:\.[0-9]+){0,2}\.[0-9]+$|^(?:0*:)*?:?0*1$/.test(
+    window.location.hostname
+  ) || window.location.protocol === "file:";

package/src/validators/checks.ts

@@ -0,0 +1,160 @@
+/**
+ * A function to check given value is a function
+ * @param value input value
+ * @returns boolean
+ */
+const isFunction = (value: any): value is Function =>
+  typeof value === "function" &&
+  Boolean(value.constructor && value.call && value.apply);
+
+/**
+ * A function to check given value is a string
+ * @param value input value
+ * @returns boolean
+ */
+const isString = (value: any): value is string => typeof value === "string";
+
+/**
+ * A function to check given value is null or not
+ * @param value input value
+ * @returns boolean
+ */
+const isNull = (value: any): value is null => value === null;
+
+/**
+ * A function to check given value is undefined
+ * @param value input value
+ * @returns boolean
+ */
+const isUndefined = (value: any): value is undefined =>
+  typeof value === "undefined";
+
+/**
+ * A function to check given value is null or undefined
+ * @param value input value
+ * @returns boolean
+ */
+const isNullOrUndefined = (value: any): boolean =>
+  isNull(value) || isUndefined(value);
+
+/**
+ * Checks if the input is a BigInt
+ * @param value input value
+ * @returns True if the input is a BigInt
+ */
+const isBigInt = (value: any): value is bigint => typeof value === "bigint";
+
+/**
+ * A function to check given value is defined
+ * @param value input value
+ * @returns boolean
+ */
+const isDefined = (value: any): boolean => !isUndefined(value);
+
+/**
+ * A function to check given value is defined and not null
+ * @param value input value
+ * @returns boolean
+ */
+const isDefinedAndNotNull = (value: any): boolean => !isNullOrUndefined(value);
+
+/**
+ * A function to check given value is defined and not null
+ * @param value input value
+ * @returns boolean
+ */
+const isDefinedNotNullAndNotEmptyString = (value: any): boolean =>
+  isDefinedAndNotNull(value) && value !== "";
+
+/**
+ * Determines if the input is of type error
+ * @param value input value
+ * @returns true if the input is of type error else false
+ */
+const isTypeOfError = (value: any): boolean => {
+  switch (Object.prototype.toString.call(value)) {
+    case "[object Error]":
+    case "[object Exception]":
+    case "[object DOMException]":
+      return true;
+    default:
+      return value instanceof Error;
+  }
+};
+
+/**
+ * A function to check given value is an array
+ * @param value input value
+ * @returns true if the input is of type array else false
+ */
+const isArray = (arg: any): arg is Array<any> => {
+  return Array.isArray(arg);
+};
+
+const isBoolean = (arg: any): arg is boolean => {
+  return typeof arg === "boolean";
+};
+
+const isNumber = (arg: any): arg is number => {
+  return typeof arg === "number";
+};
+
+const isObject = (value: any): value is object => typeof value === "object";
+
+const isObjectAndNotNull = (value: any): value is object =>
+  !isNull(value) && isObject(value) && !isArray(value);
+
+const isRegExp = (arg: any): arg is RegExp => {
+  return isObject(arg) && objectToString(arg) === "[object RegExp]";
+};
+
+const isDate = (arg: any): arg is Date => {
+  return isObject(arg) && objectToString(arg) === "[object Date]";
+};
+
+const isError = (arg: any): arg is Error => {
+  return (
+    isObject(arg) &&
+    (objectToString(arg) === "[object Error]" || arg instanceof Error)
+  );
+};
+
+const isPrimitive = (
+  arg: any
+): arg is null | boolean | number | string | symbol | undefined => {
+  return (
+    arg === null ||
+    typeof arg === "boolean" ||
+    typeof arg === "number" ||
+    typeof arg === "string" ||
+    typeof arg === "symbol" || // ES6 symbol
+    typeof arg === "undefined"
+  );
+};
+
+const objectToString = (arg: any) => {
+  return Object.prototype.toString.call(arg);
+};
+
+export {
+  isFunction,
+  isString,
+  isNull,
+  isUndefined,
+  isNullOrUndefined,
+  isTypeOfError,
+  isDefined,
+  isDefinedAndNotNull,
+  isDefinedNotNullAndNotEmptyString,
+  isBigInt,
+  isArray,
+  isBoolean,
+  isNumber,
+  isObject,
+  isObjectAndNotNull,
+  isRegExp,
+  isDate,
+  isError,
+  isPrimitive,
+  objectToString,
+};

package/src/validators/index.ts

@@ -0,0 +1,7 @@
+export * from "./address";
+export * from "./agent";
+export * from "./checks";
+export * from "./network";
+export * from "./object";
+export * from "./string";
+export * from "./uint8array";

package/src/validators/network.ts

@@ -0,0 +1,34 @@
+const objectToString = Object.prototype.toString;
+
+const isError = (value: any) => objectToString.call(value) === "[object Error]";
+
+const errorMessages = new Set([
+  "network error", // Chrome
+  "Failed to fetch", // Chrome
+  "NetworkError when attempting to fetch resource.", // Firefox
+  "The Internet connection appears to be offline.", // Safari 16
+  "Load failed", // Safari 17+
+  "Network request failed", // `cross-fetch`
+  "fetch failed", // Undici (Node.js)
+  "terminated", // Undici (Node.js)
+]);
+
+export function isNetworkError(error: any) {
+  const isValid =
+    error &&
+    isError(error) &&
+    error.name === "TypeError" &&
+    typeof error.message === "string";
+
+  if (!isValid) {
+    return false;
+  }
+
+  // We do an extra check for Safari 17+ as it has a very generic error message.
+  // Network errors in Safari have no stack.
+  if (error.message === "Load failed") {
+    return error.stack === undefined;
+  }
+
+  return errorMessages.has(error.message);
+}

package/src/validators/object.ts

@@ -0,0 +1,4 @@
+export const isNullish = (item: unknown): item is undefined | null =>
+  // Using "null" value intentionally for validation
+  // eslint-disable-next-line no-null/no-null
+  item === undefined || item === null;

package/src/validators/string.ts

@@ -0,0 +1,4 @@
+import { ValidInputTypes } from "../types";
+
+export const isHexStrict = (hex: ValidInputTypes) =>
+  typeof hex === "string" && /^((-)?0x[0-9a-f]+|(0x))$/i.test(hex);

package/src/validators/uint8array.ts

@@ -0,0 +1,17 @@
+export function isUint8Array(data: unknown | Uint8Array): data is Uint8Array {
+  return (
+    data instanceof Uint8Array ||
+    (data as { constructor: { name: string } })?.constructor?.name ===
+      "Uint8Array" ||
+    (data as { constructor: { name: string } })?.constructor?.name === "Buffer"
+  );
+}
+
+export function uint8ArrayToHexString(uint8Array: Uint8Array): string {
+  let hexString = "0x";
+  for (const e of uint8Array as any) {
+    const hex = e.toString(16);
+    hexString += hex.length === 1 ? `0${hex}` : hex;
+  }
+  return hexString;
+}

package/test/lib/events.spec.ts

@@ -0,0 +1,12 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { getCookieDomain } from "../../src/lib/event/utils";
+
+describe("getCookieDomain", () => {
+  it("should return the cookie domain format", () => {
+    expect(getCookieDomain("192.168.0.1")).to.equal("");
+    expect(getCookieDomain("localhost:3000")).to.equal("");
+    expect(getCookieDomain("example.com")).to.equal(".example.com");
+    expect(getCookieDomain("www.example.com")).to.equal(".example.com");
+  });
+});

package/test/utils/address.spec.ts

@@ -0,0 +1,14 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { toChecksumAddress } from "../../src/utils";
+
+describe("toChecksumAddress", () => {
+  it("should return the checksum of the address", () => {
+    expect(
+      toChecksumAddress("0x82827Bc8342a16b681AfbA6B979E3D1aE5F28a0e")
+    ).to.equal("0x82827Bc8342a16b681AfbA6B979E3D1aE5F28a0e");
+    expect(
+      toChecksumAddress("0x82827bc8342a16b681afba6b979e3d1ae5f28a0e")
+    ).to.equal("0x82827Bc8342a16b681AfbA6B979E3D1aE5F28a0e");
+  });
+});

package/test/utils/converter.spec.ts

@@ -0,0 +1,31 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { toSnakeCase } from "../../src/utils";
+
+describe("toSnakeCase", () => {
+  it("should convert object keys to snake case", () => {
+    expect(
+      toSnakeCase({ chainId: "12345", hashMessage: "John Doe" })
+    ).to.deep.equal({
+      chain_id: "12345",
+      hash_message: "John Doe",
+    });
+  });
+
+  it("should convert object keys to snake case, omitting keys in the omitKeys array", () => {
+    expect(
+      toSnakeCase(
+        {
+          chainId: "12345",
+          hashMessage: "John Doe",
+          "user-agent": "Mozilla/5.0",
+        },
+        ["user-agent"]
+      )
+    ).to.deep.equal({
+      chain_id: "12345",
+      hash_message: "John Doe",
+      "user-agent": "Mozilla/5.0",
+    });
+  });
+});

package/test/validators/address.spec.ts

@@ -0,0 +1,15 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { isAddress } from "../../src/validators";
+
+describe("isAddress", () => {
+  it("should return true if the input is a valid ethereum address", () => {
+    expect(isAddress("0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC")).to.equal(
+      true
+    );
+  });
+
+  it("should return false otherwise", () => {
+    expect(isAddress("o")).to.equal(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "outDir": "dist/cjs",
+    "allowJs": false,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "module": "commonjs",
+    "target": "es5",
+    "lib": ["es2015", "dom"],
+    "moduleResolution": "node",
+    "declaration": true,
+    "noImplicitThis": false,
+    "noImplicitAny": true,
+    "noUnusedParameters": true,
+    "declarationMap": true,
+    "composite": true,
+    "incremental": true,
+    "sourceMap": true,
+    "isolatedModules": true
+  },
+  "ts-node": {
+    "files": true
+  },
+  "include": ["src", "test"]
+}

package/webpack.config.ts

@@ -0,0 +1,23 @@
+import path from "path";
+
+module.exports = {
+  entry: {
+    bundle: "./src/index.ts",
+    "bundle.min": "./src/index.ts",
+  },
+  output: {
+    path: path.resolve(__dirname, "dist"),
+    filename: "index.umd.min.js",
+    libraryTarget: "umd",
+    library: "FormoAnalytics",
+    libraryExport: "FormoAnalytics",
+    umdNamedDefine: true,
+  },
+  resolve: {
+    extensions: [".ts", ".tsx", ".js"],
+  },
+  devtool: "source-map",
+  module: {
+    rules: [{ test: /\.tsx?$/, loader: "ts-loader" }],
+  },
+};