@formo/analytics 1.17.3 → 1.17.5

package/src/validators/address.ts

@@ -1,69 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,160 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,28 +0,0 @@
-{
-  "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

@@ -1,23 +0,0 @@
-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" }],
-  },
-};