@bigbinary/neeto-commons-frontend 4.14.0-beta.0 → 4.14.1

package/utils.d.ts

@@ -1,10 +1,10 @@
 import { Mixin, Subscription } from "@rails/actioncable";
 import Dayjs from "dayjs";
-import { utc as utcPlugin } from 'dayjs/plugin/utc';
-import { tz as tzPlugin } from 'dayjs/plugin/timezone';
-import { duration as durationPlugin } from 'dayjs/plugin/duration';
-import { isDayjs as isDayjsPlugin } from 'dayjs';
-import { updateLocale as updateLocalePlugin } from 'dayjs/plugin/updateLocale';
+import { utc as utcPlugin } from "dayjs/plugin/utc";
+import { tz as tzPlugin } from "dayjs/plugin/timezone";
+import { duration as durationPlugin } from "dayjs/plugin/duration";
+import { isDayjs as isDayjsPlugin } from "dayjs";
+import { updateLocale as updateLocalePlugin } from "dayjs/plugin/updateLocale";
 import React from "react";
 import { StringSchema } from "yup";
 export function resetAuthTokens(): void;
@@ -139,23 +139,31 @@ type buildUrlOptions = {
 */
 export function buildUrl(route: string, params: object, options?: buildUrlOptions): string;
 type DateTimeType = string | number | Dayjs.Dayjs | Date | null | undefined;
-export const timeFormat: {
+type HourFormatOptions = {
+  hourFormat?: "12h" | "24h";
+};
+export const createTimeFormat: (dayjsInstance: DayjsStatic) => {
   fromNow: (time: DateTimeType) => string;
-  time: (time: DateTimeType) => string;
-  timeWithSeconds: (time: DateTimeType) => string;
+  time: (time: DateTimeType, options?: HourFormatOptions) => string;
+  timeWithSeconds: (time: DateTimeType, options?: HourFormatOptions) => string;
   date: (time: DateTimeType) => string;
   dateWeek: (time: DateTimeType) => string;
   dateWeekDayExtended: (time: DateTimeType) => string;
   dateWeekWithoutYear: (time: DateTimeType) => string;
   dateWeekWithoutYearDayExtended: (time: DateTimeType) => string;
-  dateTime: (time: DateTimeType) => string;
-  dateTimeWithSeconds: (time: DateTimeType) => string;
-  dateWeekTime: (time: DateTimeType) => string;
-  dateWeekTimeDayExtended: (time: DateTimeType) => string;
-  extended: (time: DateTimeType) => string;
+  dateTime: (time: DateTimeType, options?: HourFormatOptions) => string;
+  dateTimeWithSeconds: (time: DateTimeType, options?: HourFormatOptions) => string;
+  dateWeekTime: (time: DateTimeType, options?: HourFormatOptions) => string;
+  dateWeekTimeDayExtended: (time: DateTimeType, options?: HourFormatOptions) => string;
+  timeWeekday: (time: DateTimeType, options?: HourFormatOptions) => string;
+  monthDay: (time: DateTimeType) => string;
+  monthYear: (time: DateTimeType) => string;
+  extended: (time: DateTimeType, options?: HourFormatOptions) => string;
   default: (time: DateTimeType) => string;
-  defaultWithTime: (time: DateTimeType) => string;
+  defaultWithTime: (time: DateTimeType, options?: HourFormatOptions) => string;
 };
+export const createDateFormat: typeof createTimeFormat;
+export const timeFormat: ReturnType<typeof createTimeFormat>;
 /**
  *
  * The dateFormat and timeFormat functions are aliases of each other, and they
@@ -164,7 +172,9 @@ export const timeFormat: {
  *
  * a convenient way to format date and time values according to specific patterns
  *
- * and display them in a human-readable format.
+ * and display them in a human-readable format. Learn more about the real-world
+ *
+ * scenarios at https://youtu.be/h3L9nb0G0RI.
  *
  * @example 
  *
@@ -182,17 +192,17 @@ export const timeFormat: {
  * dateFormat.date(date); // "Jan 1, 2020"
  * timeFormat.date(date); // "Jan 1, 2020"
  * 
- * dateFormat.dateWeek(date); // "Jan 1, 2020 Wed"
- * timeFormat.dateWeek(date); // "Jan 1, 2020 Wed"
+ * dateFormat.dateWeek(date); // "Wed, Jan 1, 2020"
+ * timeFormat.dateWeek(date); // "Wed, Jan 1, 2020"
  * 
- * dateFormat.dateWeekDayExtended(date); // "Jan 1, 2020 Wednesday"
- * timeFormat.dateWeekDayExtended(date); // "Jan 1, 2020 Wednesday"
+ * dateFormat.dateWeekDayExtended(date); // "Wednesday, Jan 1, 2020"
+ * timeFormat.dateWeekDayExtended(date); // "Wednesday, Jan 1, 2020"
  * 
- * dateFormat.dateWeekWithoutYear(date); // "Jan 1, Wed"
- * timeFormat.dateWeekWithoutYear(date); // "Jan 1, Wed"
+ * dateFormat.dateWeekWithoutYear(date); // "Wed, Jan 1"
+ * timeFormat.dateWeekWithoutYear(date); // "Wed, Jan 1"
  * 
- * dateFormat.dateWeekWithoutYearDayExtended(date); // "Jan 1, Wednesday"
- * timeFormat.dateWeekWithoutYearDayExtended(date); // "Jan 1, Wednesday"
+ * dateFormat.dateWeekWithoutYearDayExtended(date); // "Wednesday, Jan 1"
+ * timeFormat.dateWeekWithoutYearDayExtended(date); // "Wednesday, Jan 1"
  * 
  * dateFormat.dateTime(date); // "Jan 1, 2020 12:00 AM"
  * timeFormat.dateTime(date); // "Jan 1, 2020 12:00 AM"
@@ -200,21 +210,44 @@ export const timeFormat: {
  * dateFormat.dateTimeWithSeconds(date); // "Jan 1, 2020 12:00:00 AM"
  * timeFormat.dateTimeWithSeconds(date); // "Jan 1, 2020 12:00:00 AM"
  * 
- * dateFormat.dateWeekTime(date); // "Jan 1, 2020 Wed 12:00 AM"
- * timeFormat.dateWeekTime(date); // "Jan 1, 2020 Wed 12:00 AM"
+ * dateFormat.dateWeekTime(date); // "Wed, Jan 1, 2020 12:00 AM"
+ * timeFormat.dateWeekTime(date); // "Wed, Jan 1, 2020 12:00 AM"
  * 
- * dateFormat.dateWeekTimeDayExtended(date); // "Jan 1, 2020 Wednesday 12:00 AM"
- * timeFormat.dateWeekTimeDayExtended(date); // "Jan 1, 2020 Wednesday 12:00 AM"
+ * dateFormat.dateWeekTimeDayExtended(date); // "Wednesday, Jan 1, 2020 12:00 AM"
+ * timeFormat.dateWeekTimeDayExtended(date); // "Wednesday, Jan 1, 2020 12:00 AM"
  * 
  * dateFormat.extended(date); // "Wednesday January 1, 2020 12:00 AM (3 years ago)"
  * timeFormat.extended(date); // "Wednesday January 1, 2020 12:00 AM (3 years ago)"
  * 
+ * dateFormat.timeWeekday(date); // "12:00 AM Wednesday"
+ * timeFormat.timeWeekday(date); // "12:00 AM Wednesday"
+ * 
+ * dateFormat.monthDay(date); // "January 1"
+ * timeFormat.monthDay(date); // "January 1"
+ * 
+ * dateFormat.monthYear(date); // "January 2020"
+ * timeFormat.monthYear(date); // "January 2020"
+ * 
  * dateFormat.default(date); // This will return date in user date format in globalProps
  * timeFormat.default(date); // This will return date in user date format in globalProps
  * 
  * dateFormat.defaultWithTime(date); // This will return date time in user date format in globalProps
  * timeFormat.defaultWithTime(date); // This will return date time in user date format in globalProps
  * @endexample
+ * Methods that include time (time, timeWithSeconds, dateTime,
+ *
+ * dateTimeWithSeconds, dateWeekTime, dateWeekTimeDayExtended, extended,
+ *
+ * defaultWithTime, timeWeekday) accept an optional second argument to override
+ *
+ * the global hour format:
+ *
+ * @example 
+ *
+ * dateFormat.time(date, { hourFormat: "24h" }); // "00:00" (even if global is 12h)
+ * dateFormat.time(date, { hourFormat: "12h" }); // "12:00 AM" (even if global is 24h)
+ * dateFormat.dateTime(date, { hourFormat: "24h" }); // "Jan 1, 2020 00:00"
+ * @endexample
  * All neeto-applications should be using any one of these styles (according to the
  *
  * space available) to display date and time unless if the case is too specific to
@@ -575,39 +608,9 @@ export function showThumbsUpToastr(): void;
  * @endexample
 */
 export function slugValidator(label: string): StringSchema;
-/**
- *
- * The captureAnalyticsEvent is a utility function which facilitates logging user
- *
- * events to Mixpanel.
- *
- * @example 
- *
- * import { captureAnalyticsEvent } from "@bigbinary/neeto-commons-frontend/utils";
- * // ...
- * 
- * captureAnalyticsEvent("event_name", { subdomain: "spinkart" });
- * 
- * // The second argument is optional, containing additional data to log as part of the event.
- * @endexample
-*/
 export function captureAnalyticsEvent(name: string, properties?: {
   [key: string]: any;
 }): void;
-/**
- *
- * The captureAnalyticsPageView is a utility function which facilitates logging user page views to Mixpanel.
- *
- * @example 
- *
- * import { captureAnalyticsPageView } from "@bigbinary/neeto-commons-frontend/utils";
- * // ...
- * 
- * captureAnalyticsPageView("page_name", { additional: "information" });
- * 
- * // The second argument is optional, containing additional data to log as part of the page.
- * @endexample
-*/
 export function captureAnalyticsPageView(page: string, properties?: {
   [key: string]: string;
 }): void;
@@ -680,4 +683,146 @@ export function buildNestedAttributesPayload(modifiedValues: {
  * }, []);
  * @endexample
 */
-export function loadGoogleFonts(fontFamilies: string[]): void;
+export function loadGoogleFonts(fontFamilies: string[]): void;
+
+// Device Information Types
+export interface DeviceInformationOptions {
+  appType?: string;
+}
+export interface DeviceInfo {
+  type: string;
+  os: string;
+  osVersion: string;
+  screen: {
+    width: number;
+    height: number;
+    pixelRatio: number;
+    colorDepth: number;
+  };
+  viewport: {
+    width: number;
+    height: number;
+  };
+  memoryGB: number | null;
+}
+export interface BrowserInfo {
+  name: string;
+  version: string;
+  userAgent: string;
+  javaScriptEnabled: boolean;
+  cookiesEnabled: boolean;
+  websockets: boolean;
+  webgl: boolean;
+  doNotTrack: string | null;
+  mimeTypes: string[];
+  network: {
+    effectiveType: string;
+    downlink: number;
+    rtt: number;
+    saveData: boolean;
+  } | null;
+}
+export interface PermissionsInfo {
+  microphone: string;
+  camera: string;
+  geolocation: string;
+  notifications: string;
+  media: {
+    hasMic: boolean | null;
+    hasCamera: boolean | null;
+  };
+}
+export interface MetaInfo {
+  time: {
+    zone: string;
+    offset: string;
+  };
+  referrer: string;
+  appType: string;
+}
+export interface DeviceInformationResult {
+  device: DeviceInfo;
+  browser: BrowserInfo;
+  permissions: PermissionsInfo;
+  meta: MetaInfo;
+}
+/**
+ *
+ * The deviceInformation function collects comprehensive device and browser
+ *
+ * information including device specifications, browser details, permissions, and
+ *
+ * network information. This function is useful for analytics, debugging, feature
+ *
+ * detection, and providing device-specific experiences.
+ *
+ * A Promise that resolves to an object containing:
+ *
+ * @example 
+ *
+ * const deviceInfo = await deviceInformation();
+ * 
+ * console.log(deviceInfo.device.type); // "desktop", "mobile", or "tablet"
+ * console.log(deviceInfo.browser.name); // "Chrome", "Firefox", "Safari", etc.
+ * console.log(deviceInfo.permissions.microphone); // "granted", "denied", "prompt", or "unsupported"
+ * @endexample
+ * @example 
+ *
+ * {
+ *   device: {
+ *     type: "desktop",
+ *     os: "macOS",
+ *     osVersion: "13.0",
+ *     screen: {
+ *       width: 1920,
+ *       height: 1080,
+ *       pixelRatio: 2,
+ *       colorDepth: 24
+ *     },
+ *     viewport: {
+ *       width: 1440,
+ *       height: 900
+ *     },
+ *     memoryGB: 16
+ *   },
+ *   browser: {
+ *     name: "Chrome",
+ *     version: "119.0.0.0",
+ *     userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)...",
+ *     javaScriptEnabled: true,
+ *     cookiesEnabled: true,
+ *     websockets: true,
+ *     webgl: true,
+ *     doNotTrack: null,
+ *     mimeTypes: ["text/html", "text/plain", ...],
+ *     network: {
+ *       effectiveType: "4g",
+ *       downlink: 10,
+ *       rtt: 50,
+ *       saveData: false
+ *     }
+ *   },
+ *   permissions: {
+ *     microphone: "prompt",
+ *     camera: "denied",
+ *     geolocation: "granted",
+ *     notifications: "unsupported",
+ *     media: {
+ *       hasMic: true,
+ *       hasCamera: true
+ *     }
+ *   },
+ *   meta: {
+ *     timezone: "America/New_York",
+ *     referrer: "https://example.com"
+ *   },
+ *   serverDerived: {
+ *     country: "US",
+ *     region: "California",
+ *     city: "San Francisco"
+ *   }
+ * }
+ * @endexample
+*/
+export function deviceInformation(options?: DeviceInformationOptions): Promise<DeviceInformationResult>;
+export function getAppType(): "extension" | "desktop" | "mobile" | "web";

package/configs/eslint/globals.js

@@ -1,14 +0,0 @@
-module.exports = {
-  // Globals can be disabled with the string "off"
-  // "writable" to allow the variable to be overwritten or "readonly" to disallow overwriting.
-  globals: {
-    Atomics: "readonly",
-    SharedArrayBuffer: "readonly",
-    // Makes logger function available everywhere. Else eslint will complaint of undef-var.
-    logger: "readonly",
-    module: "writable",
-    // Makes props obtained from Rails backend available everywhere in this project.
-    globalProps: "readonly",
-    preval: "readonly",
-  },
-};

package/configs/eslint/imports/enforced.js

@@ -1,29 +0,0 @@
-module.exports = {
-  rules: {
-    // not-auto-fixable: Prefer a default export if module exports a single name.
-    "import/prefer-default-export": "off",
-    // not-auto-fixable: Forbid a module from importing a module with a dependency path back to itself.
-    "import/no-cycle": ["warn", { maxDepth: 1, ignoreExternal: true }],
-    // not-auto-fixable: Prevent unnecessary path segments in import and require statements.
-    "import/no-useless-path-segments": ["error", { noUselessIndex: true }],
-    // not-auto-fixable: Report any invalid exports, i.e. re-export of the same name.
-    "import/export": "error",
-    // not-auto-fixable: Forbid the use of mutable exports with var or let.
-    "import/no-mutable-exports": "error",
-    // not-auto-fixable: Ensure all imports appear before other statements.
-    "import/first": "error",
-    // not-auto-fixable: Ensure all exports appear after other statements.
-    "import/exports-last": "error",
-    // auto-fixable: Enforce a newline after import statements.
-    "import/newline-after-import": ["error", { count: 1 }],
-    // auto-fixable: Remove file extensions for import statements.
-    "import/extensions": [
-      "error",
-      "never",
-      {
-        ignorePackages: true,
-        pattern: { json: "always", ico: "always", yml: "always" },
-      },
-    ],
-  },
-};

package/configs/eslint/imports/order.js

@@ -1,65 +0,0 @@
-const { buildPathGroupsBasedOnWebpackAliases } = require("../helpers");
-
-const pathGroups = buildPathGroupsBasedOnWebpackAliases({});
-
-const pathGroupForKeepingReactImportsAtTop = {
-  pattern: "react+(-native|)",
-  group: "external",
-  position: "before",
-};
-
-/*
-Example pathGroups structure. Adding this here
-so that if anyone wants to add custom config,
-they can make use of this:
-[
-  { pattern: 'apis/**', group: 'internal' },
-  { pattern: 'common/**', group: 'internal' },
-  { pattern: 'components/**', group: 'internal' },
-  { pattern: 'constants/**', group: 'internal' },
-  { pattern: 'contexts/**', group: 'internal' },
-  { pattern: 'reducers/**', group: 'internal' },
-  { pattern: 'Constants', group: 'internal' },
-  { pattern: 'neetoui/**', group: 'external' },
-  {
-    pattern: 'react+(-native|)',
-    group: 'external',
-    position: 'before'
-  }
-]
-*/
-pathGroups.push(pathGroupForKeepingReactImportsAtTop);
-
-module.exports = {
-  rules: {
-    // auto-fixable: Enforce a convention in module import order - we enforce https://www.bigbinary.com/react-best-practices/sort-import-statements
-    "import/order": [
-      "error",
-      {
-        "newlines-between": "always",
-        alphabetize: { order: "asc", caseInsensitive: true },
-        warnOnUnassignedImports: true,
-        groups: [
-          "builtin",
-          "external",
-          "internal",
-          "index",
-          "sibling",
-          "parent",
-          "object",
-          "type",
-        ],
-        /*
-         * Currently we check for existence of webpack alias
-         * config and then iterate over the aliases and create
-         * these pathGroups. Only caveat with this mechanism
-         * is that in VSCode eslint plugin won't dynamically
-         * read it. But eslint cli would!
-         */
-        pathGroups,
-        // Ignore react imports so that they're always ordered to the top of the file.
-        pathGroupsExcludedImportTypes: ["react", "react-native"],
-      },
-    ],
-  },
-};

package/configs/eslint/index.js

@@ -1,172 +0,0 @@
-module.exports = {
-  env: {
-    browser: true, // window object etc part of browser are made available globally.
-    es2020: true, // to include BigInt support
-    es6: true,
-    commonjs: true,
-    node: true,
-  },
-  /*
-   * The order of extending each plugin matters a LOT!!
-   * Thus don't change order of items in this array
-   * unless you're sure of it.
-   */
-  extends: [
-    "plugin:@bigbinary/neeto/recommended",
-    "plugin:cypress/recommended",
-    "plugin:json/recommended",
-    "eslint:recommended",
-    "plugin:react/recommended",
-    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/globals",
-    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/imports/order",
-    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/overrides",
-    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/imports/enforced",
-    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/react",
-    "./node_modules/@bigbinary/neeto-commons-frontend/configs/eslint/promise",
-    "prettier",
-  ],
-  settings: {
-    react: { version: "detect" },
-    // We need this for the import/extensions rule to work: https://github.com/import-js/eslint-plugin-import#importextensions
-    "import/resolver": {
-      node: {
-        extensions: [".js", ".jsx", ".ts", ".tsx", ".svg", ".json"],
-      },
-    },
-  },
-  parserOptions: {
-    ecmaFeatures: { jsx: true },
-    ecmaVersion: 2018,
-    sourceType: "module",
-    babelOptions: { presets: ["@babel/preset-react"] },
-  },
-  // babel-eslint is deprecated now. This is the latest package.
-  parser: "@babel/eslint-parser",
-  plugins: [
-    "react",
-    "prettier",
-    "import",
-    "react-hooks",
-    "promise",
-    "jam3",
-    "unused-imports",
-    "sonarjs",
-    "security",
-    "xss",
-    "@bigbinary/neeto",
-  ],
-  rules: {
-    // auto-fixable: Respect all Prettier rules and apply it.
-    "prettier/prettier": "error",
-    // not-auto-fixable: No unused variables allowed.
-    "no-unused-vars": [
-      "error",
-      {
-        args: "all",
-        argsIgnorePattern: "^_",
-        destructuredArrayIgnorePattern: "^_",
-        caughtErrors: "all",
-      },
-    ],
-    // not-auto-fixable: No undefined variables allowed.
-    "no-undef": "error",
-    // not-auto-fixable: Dont use console statements. Use logger which babel will remove during bundling.
-    "no-console": "error",
-    // not-auto-fixable: require `return` statements to either always or never specify values.
-    "consistent-return": "error",
-    // auto-fixable: disallows repeating variable name when declaring object properties.
-    "object-shorthand": "error",
-    // auto-fixable: sadly this doesn't support guard clauses yet.
-    "padding-line-between-statements": [
-      "error",
-      { blankLine: "always", prev: "if", next: ["if", "return"] },
-      // The newline-before-return rule is deprecated in favor of the following:
-      { blankLine: "always", prev: "*", next: "return" },
-      // Add newline between function declarations
-      {
-        blankLine: "always",
-        prev: [
-          "block",
-          "multiline-block-like",
-          "function",
-          "iife",
-          "multiline-const",
-          "multiline-expression",
-        ],
-        next: ["function", "iife", "multiline-const", "multiline-expression"],
-      },
-    ],
-    // auto-fixable: Single line statements needn't have any braces. But in all other cases enforce curly braces.
-    curly: ["error", "multi-line"],
-    // auto-fixable: Remove the else part, if the "if" or "else-if" chain has a return statement
-    "no-else-return": "error",
-    // not-auto-fixable: Prevent un-sanitized dangerouslySetInnerHTML.
-    "jam3/no-sanitizer-with-danger": [
-      2,
-      { wrapperName: ["dompurify", "sanitizer", "sanitize"] },
-    ],
-    // auto-fixable: Requires trailing commas when the last element or property is in a different line than the closing ] or }
-    "comma-dangle": [
-      "error",
-      {
-        arrays: "always-multiline",
-        objects: "always-multiline",
-        imports: "always-multiline",
-        exports: "always-multiline",
-        functions: "never",
-      },
-    ],
-    // auto-fixable: If a variable is never reassigned, using the const declaration is better.
-    "prefer-const": "error",
-    // auto-fixable: It is considered good practice to use the type-safe equality operators === and !==.
-    eqeqeq: "error",
-    // not-auto-fixable: Rule flags optional chaining expressions in positions where short-circuiting to undefined causes throwing a TypeError afterward.
-    "no-unsafe-optional-chaining": "error",
-    // auto-fixable: Remove all unused imports.
-    "unused-imports/no-unused-imports": "error",
-    // auto-fixable-1-level-deep: Using nested ternary operators make the code unreadable. Use if/else or switch with if/else. If it's JSX then move it out into a function or a variable. It's fine to use nestedTernary in JSX when it makes code more readable.
-    "no-nested-ternary": "warn",
-    // auto-fixable: Enforces no braces where they can be omitted.
-    "arrow-body-style": ["error", "as-needed"],
-    // auto-fixable: Suggests using template literals instead of string concatenation.
-    "prefer-template": "error",
-    // auto-fixable: Disallows ternary operators when simpler alternatives exist.
-    "no-unneeded-ternary": ["error", { defaultAssignment: false }],
-    // not-auto-fixable: Enforces declaring default params last
-    "default-param-last": "error",
-    // not-auto-fixable: Remove redundant async-awaits
-    "no-return-await": "warn",
-    // not-auto-fixable: Disallow empty block statements
-    "no-empty": ["error", { allowEmptyCatch: true }],
-    // not-auto-fixable: Enforce return statements in callbacks of array methods.
-    "array-callback-return": ["error"],
-    // auto-fixable: Partially fixable. Unless there's a need to the this keyword, there's no advantage of using a plain function.
-    "prefer-arrow-callback": ["error", { allowUnboundThis: true }],
-    // not-auto-fixable: Convert multiple imports from same module into a single import.
-    "no-duplicate-imports": ["error", { includeExports: true }],
-    // auto-fixable: Partially fixable. In JavaScript, there are a lot of different ways to convert value types. Allow only readable coercions.
-    "no-implicit-coercion": ["error", { allow: ["!!"] }],
-    // auto-fixable: Require let or const instead of var.
-    "no-var": "error",
-    // auto-fixable: This rule conflicts with prettier rules. Thus we've NOT kept this rule in react file. This rule ensures we don't add blank lines in JSX.
-    "react/jsx-newline": ["error", { prevent: true }],
-    // not-auto-fixable: Disallow async functions which have no await expression
-    "require-await": "error",
-    // auto-fixable: This rule ensures immediate returns in functions where constants are declared and then directly returned.
-    "sonarjs/prefer-immediate-return": "error",
-    // not-auto-fixable: This rule enforces merging adjacent collapsible if statements.
-    "sonarjs/no-collapsible-if": "error",
-    // not-auto-fixable: This rule prevents identical conditions inside if-else statements.
-    "sonarjs/no-identical-conditions": "error",
-    // not-auto-fixable: This rule prevents using a function with no return as output, passing it to another function, or assigning its result to a variable.
-    "sonarjs/no-use-of-empty-return-value": "error",
-    // not-auto-fixable: This rule prevents using loops with at most one iteration.
-    "sonarjs/no-one-iteration-loop": "error",
-    // not-auto-fixable: This rule prevents using catch clause that only throws an error.
-    "sonarjs/no-useless-catch": "error",
-    // not-auto-fixable: This rule warns against "eval(variable)" which can allow an attacker to run arbitrary code inside your process.
-    "security/detect-eval-with-expression": "warn",
-    // not-auto-fixable: This rule ensures that you are calling escape function before location.href assignment.
-    "xss/no-location-href-assign": ["error", { escapeFunc: "sanitize" }],
-  },
-};

package/configs/eslint/overrides.js

@@ -1,26 +0,0 @@
-module.exports = {
-  // Currently we are using this section for excluding certain files from certain rules.
-  overrides: [
-    {
-      files: [
-        ".eslintrc.js",
-        ".prettierrc.js",
-        "app/assets/**/*",
-        "app/javascript/packs/**/*",
-        "*.json",
-      ],
-      rules: {
-        "import/order": "off",
-        "react-hooks/rules-of-hooks": "off",
-      },
-    },
-    {
-      files: ["app/javascript/packs/**/*.{js,jsx}"],
-      rules: { "no-redeclare": "off" },
-    },
-    {
-      files: ["**/*.spec.js", "**/*.spec.jsx", "**/*.test.jsx"],
-      env: { jest: true },
-    },
-  ],
-};

package/configs/eslint/promise.js

@@ -1,8 +0,0 @@
-module.exports = {
-  rules: {
-    // not-auto-fixable: ensure people use async/await promising chaining rather than using "then-catch-finally" statements
-    "promise/prefer-await-to-then": "error",
-    // auto-fixable: avoid calling "new" on a Promise static method like reject, resolve etc
-    "promise/no-new-statics": "error",
-  },
-};