casper-context 0.1.0

package/dist/utils/utilityHelpers.js

@@ -0,0 +1,606 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isContextInstanceDeclare = exports.getInsertionIndex = exports.getFilePathHASH = exports.findContextByVar = exports.ESLINT_GLOBAL_JS_PATH = exports.CONTEXT_FILE_PATH = exports.CASPER_CONFIG_PATH = void 0;
+exports.isExcludeFile = isExcludeFile;
+exports.log = log;
+exports.readCasperConfig = readCasperConfig;
+exports.registerVariable = void 0;
+exports.resetVarsForFile = resetVarsForFile;
+exports.resolveReact = resolveReact;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _crypto = _interopRequireDefault(require("crypto"));
+var _constants = require("./constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @fileoverview Path resolution and configuration management for Casper Context.
+ * This module handles the physical location of generated context files, 
+ * ESLint configurations, and the initialization of the library's runtime settings.
+ */
+
+/**
+ * Core Node.js modules used throughout the Casper Babel utilities:
+ * - `path` for resolving and normalizing file system paths.
+ * - `fs` for reading, writing, and checking the existence of files.
+ * - `crypto` for generating file-based hashes and unique identifiers.
+ */
+
+/**
+ * Casper-specific constants imported from './constants':
+ *
+ * - Context and file naming:
+ *   - `CONTEXT_FOLDER_NAME`, `CONTEXT_FILE_NAME`
+ * - File and hash utilities:
+ *   - `NO_FILE`, `FILE_HASH_MD5`, `UNICODE_UTF8`, `DIGEST_HEX`
+ * - React & component prefixes:
+ *   - `_CCTX_CMP_NAME_PREFIX`, `_CCTX_UNDUS_CORE_REACT`
+ * - File/folder exclusions:
+ *   - `GBL_CONTEXT_JS`, `NODE_MODULES`, `FOLDER_DIST`, `FOLDER_BUILD`
+ * - ESLint & config integration:
+ *   - `CASPER_ESLINT_GLOBAL_JS`, `CASPER_CONFIG_FILE`, `GLOBAL_PREFIX`
+ * - Debugging utilities:
+ *   - `CASPER_DEBUG_LOG_FILE_NAME`, `CASPER_STRING_TYPE`, `COLORS`, `CONTEXT_NAMESPACE`, 
+ *   - `CASPER_LOG_TYPE_ERROR`
+ * - JavaScript directive:
+ *   - `USE_STRICT`
+ */
+
+/**
+ * The absolute system path to the generated global context file.
+ * @type {string}
+ * @description Typically resolves to '[root]/src/scopeContext/gblContext.js'.
+ */
+const CONTEXT_FILE_PATH = exports.CONTEXT_FILE_PATH = _path.default.join(process.cwd(), _constants.CONTEXT_FOLDER_NAME, _constants.CONTEXT_FILE_NAME);
+
+/**
+ * The absolute system path to the auto-generated ESLint globals file.
+ * @type {string}
+ * @description Used to inject `_$_` variables into the ESLint environment to prevent 'undefined variable' errors.
+ */
+const ESLINT_GLOBAL_JS_PATH = exports.ESLINT_GLOBAL_JS_PATH = _path.default.resolve(process.cwd(), _constants.CASPER_ESLINT_GLOBAL_JS);
+
+/**
+ * The absolute system path to the Casper Context configuration file (.casperctxrc.json).
+ * @type {string}
+ */
+const CASPER_CONFIG_PATH = exports.CASPER_CONFIG_PATH = _path.default.join(process.cwd(), _constants.CASPER_CONFIG_FILE);
+
+/**
+ * Default fallback configuration for Casper Context plugin.
+ *
+ * This configuration is automatically applied when a project does not
+ * provide a `.casperctxrc.json` configuration file in its root directory.
+ *
+ * @property {string} prefix - Prefix used to identify Casper context variables.
+ * Context variables must begin with this sequence (Default: '_$_').
+ *
+ * @property {boolean} debug - Enables or disables verbose logging during
+ * the Babel transformation process. Useful for debugging plugin behavior.
+ *
+ * @property {string[]} debug_levels - List of log levels allowed when debug mode
+ * is enabled. This controls which types of log messages are displayed.
+ * possiable values: 'reset','info','warn','error', 'debug', 'trace'
+ * @private
+ */
+const DEFAULT_CONFIG = {
+  prefix: _constants.GLOBAL_PREFIX,
+  debug: false,
+  debug_levels: [_constants.CASPER_LOG_TYPE_ERROR]
+};
+const IS_PROD = process.env.NODE_ENV === "production";
+
+/**
+ * Generates a short, deterministic hash based on a file’s absolute path.
+ *
+ * This function resolves the given file path to an absolute path and produces
+ * a truncated MD5 hash. It is commonly used to create stable, filesystem-based
+ * identifiers for files that remain consistent across executions.
+ *
+ * @param {string} fileName - The file path to hash. Can be relative or absolute.
+ *
+ * @returns {string} An 8-character hexadecimal hash derived from the file’s
+ *                   absolute path, or `NO_FILE` if hashing fails.
+ *
+ * @important
+ * - Uses the absolute path (`path.resolve`) to ensure consistency regardless
+ *   of the current working directory.
+ * - The hash is generated using MD5 and truncated to the first 8 characters
+ *   for compactness (not intended for cryptographic security).
+ * - `FILE_HASH_MD5`, `UNICODE_UTF8`, `DIGEST_HEX`, and `NO_FILE` are assumed
+ *   to be predefined constants.
+ * - Errors (invalid path, filesystem issues, crypto failures) are safely
+ *   caught and result in returning `NO_FILE`.
+ * - This function is deterministic: the same file path will always produce
+ *   the same hash.
+ */
+const getFilePathHASH = fileName => {
+  try {
+    const abs = _path.default.resolve(fileName);
+    return _crypto.default.createHash(_constants.FILE_HASH_MD5).update(abs, _constants.UNICODE_UTF8).digest(_constants.DIGEST_HEX).slice(0, 8);
+  } catch (e) {
+    return _constants.NO_FILE;
+  }
+};
+
+/**
+ * Registers a component-scoped variable in a virtual registry and returns its context name.
+ *
+ * This function ensures that variables belonging to the same component are grouped
+ * under a single generated context name. If the variable is already registered for
+ * the given component hash, the existing context name is returned without mutation.
+ * Otherwise, the variable and its default value are recorded in the registry.
+ *
+ * @param {string} componentNameHash - A unique, deterministic hash representing a component.
+ *                                    Used as the registry key to scope variables per component.
+ * @param {string} varName - The name of the variable to register within the component context.
+ * @param {*} defaultValue - The default value associated with the variable. Stored for
+ *                           initializing context state.
+ * @param {Object} virtualRegistry - A mutable in-memory registry object used to track
+ *                                   component variables, context names, and defaults.
+ *
+ * @returns {string|undefined} The generated or existing context name associated with
+ *                             the component, or `undefined` if an error occurs.
+ *
+ * @important
+ * - The registry structure per component hash follows this shape:
+ *   ```js
+ *   {
+ *     varNames: string[],
+ *     ctxName: string | null,
+ *     defaults: Record<string, any>
+ *   }
+ *   ```
+ * - `_CCTX_CMP_NAME_PREFIX` is assumed to be a predefined constant used to namespace
+ *   generated context names.
+ * - Each component hash maps to exactly one context name.
+ * - Variables are registered idempotently: re-registering the same variable will not
+ *   duplicate entries.
+ * - This function mutates `virtualRegistry` directly.
+ * - Errors are silently caught; consider logging in debug or development builds.
+ */
+exports.getFilePathHASH = getFilePathHASH;
+const registerVariable = (componentNameHash, varName, defaultValue, virtualRegistry) => {
+  try {
+    if (!virtualRegistry[componentNameHash]) {
+      virtualRegistry[componentNameHash] = {
+        varNames: [],
+        ctxName: null,
+        defaults: {}
+      };
+    }
+    if (virtualRegistry[componentNameHash] && virtualRegistry[componentNameHash].varNames.includes(varName)) {
+      return virtualRegistry[componentNameHash].ctxName;
+    }
+    const ctxName = `${_constants._CCTX_CMP_NAME_PREFIX}${componentNameHash}`;
+    virtualRegistry[componentNameHash].ctxName = ctxName;
+    virtualRegistry[componentNameHash].varNames = [...virtualRegistry[componentNameHash].varNames, varName];
+    const newDefaults = {
+      ...virtualRegistry[componentNameHash].defaults
+    };
+    newDefaults[varName] = defaultValue;
+    virtualRegistry[componentNameHash].defaults = newDefaults;
+    return ctxName;
+  } catch (e) {
+    log('error', '[::registerVariable::]', e.message);
+  }
+};
+
+/**
+ * Finds the component context identifier associated with a given variable name.
+ *
+ * This function searches through the virtual registry and returns the component
+ * hash (registry key) whose registered variable list contains the specified variable.
+ * It is typically used to resolve which component context manages a given variable.
+ *
+ * @param {string} varName - The variable name to search for in the registry.
+ * @param {Object} virtualRegistry - The in-memory registry that stores component
+ *                                   context data, including variable mappings.
+ *
+ * @returns {string|null} The component hash (registry key) associated with the variable,
+ *                        or `null` if the variable is not registered in any context.
+ *
+ * @important
+ * - The registry is expected to follow this structure:
+ *   ```js
+ *   {
+ *     [componentHash]: {
+ *       varNames: string[],
+ *       ctxName: string,
+ *       defaults: Record<string, any>
+ *     }
+ *   }
+ *   ```
+ * - The function performs a linear search through registry entries.
+ * - Returns the registry key (component hash), not the generated context name.
+ * - Does **not** mutate the registry.
+ * - Errors are silently caught; consider adding logging for debugging.
+ */
+exports.registerVariable = registerVariable;
+const findContextByVar = (varName, virtualRegistry) => {
+  try {
+    for (const [ctxName, ctxData] of Object.entries(virtualRegistry)) {
+      if (ctxData.varNames && ctxData.varNames.includes(varName)) {
+        return ctxName;
+      }
+    }
+    return null;
+  } catch (e) {
+    log('error', '[::findContextByVar::]', e.message);
+  }
+};
+
+/**
+ * Checks whether a context instance variable is already declared within a block scope.
+ *
+ * This utility scans the statements inside a given BlockStatement path and determines
+ * if a variable declaration with the specified name already exists. It is primarily
+ * used to prevent duplicate `useContext` or context-instance declarations from being
+ * injected multiple times during AST transformations.
+ *
+ * @param {NodePath} path - Babel NodePath pointing to a `BlockStatement`
+ *                          (typically a component or function body).
+ * @param {Object} t - Babel types helper (`@babel/types`) used for AST node checks.
+ * @param {string} varName - The variable name to look for in existing declarations.
+ *
+ * @returns {boolean} `true` if a variable declaration with the given name is found,
+ *                    otherwise `false`.
+ *
+ * @important
+ * - Only inspects **top-level statements** within the provided block body.
+ * - Detects `var`, `let`, and `const` declarations.
+ * - Does **not** traverse nested blocks or scopes.
+ * - Intended as a guard to ensure idempotent AST injection.
+ * - Errors are silently caught; add logging if visibility is required.
+ */
+exports.findContextByVar = findContextByVar;
+const isContextInstanceDeclare = (path, t, varName) => {
+  try {
+    return path.node.body.some(stmt => {
+      if (!t.isVariableDeclaration(stmt)) return false;
+      return stmt.declarations.some(decl => t.isIdentifier(decl.id, {
+        name: varName
+      }));
+    });
+  } catch (e) {
+    log('error', '[::isContextInstanceDeclare::]', e.message);
+  }
+};
+
+/**
+ * Determines the correct insertion index for injecting new statements
+ * into a function or program body.
+ *
+ * If the first statement is a `"use strict"` directive, the insertion
+ * point is moved **after** it to preserve directive semantics.
+ * Otherwise, insertion occurs at the start of the body.
+ *
+ * This utility is commonly used when inserting context hooks,
+ * variable declarations, or other setup code during Babel AST transforms.
+ *
+ * @param {Array} body - An array of AST statements (e.g. `BlockStatement.body`).
+ * @param {Object} t - Babel types helper (`@babel/types`) used for node checks.
+ *
+ * @returns {number} The index at which new statements should be inserted.
+ *
+ * @important
+ * - Only checks the **first statement** for a `"use strict"` directive.
+ * - Assumes `body` is a valid statement array.
+ * - Preserves directive ordering and avoids breaking strict mode.
+ * - Errors are silently swallowed; consider logging for debugging.
+ */
+exports.isContextInstanceDeclare = isContextInstanceDeclare;
+const getInsertionIndex = (body, t) => {
+  try {
+    let index = 0;
+    if (body[0] && t.isExpressionStatement(body[0]) && t.isStringLiteral(body[0].expression, {
+      value: _constants.USE_STRICT
+    })) {
+      index = 1;
+    }
+    return index;
+  } catch (e) {
+    log('error', '[::getInsertionIndex::]', e.message);
+  }
+};
+
+/**
+ * Appends debug information to the Casper debug log file.
+ *
+ * This helper writes a formatted log entry to a file located in the
+ * current working directory. Each argument is converted into a string:
+ * - String values are written as-is.
+ * - Non-string values are serialized using `JSON.stringify`.
+ *
+ * All arguments are concatenated with spaces and written as a single
+ * log line followed by a newline character.
+ *
+ * @param {...any} args - One or more values to log. Supports strings,
+ * objects, arrays, numbers, booleans, or any serializable value.
+ *
+ * @returns {void} This function does not return a value.
+ *
+ * @important
+ * - Logging is synchronous (`fs.appendFileSync`), which may impact performance
+ *   if called frequently or inside hot execution paths.
+ * - Log file location is resolved relative to `process.cwd()`.
+ * - Non-serializable objects may throw during `JSON.stringify`.
+ * - Errors are silently swallowed to prevent logging from breaking execution.
+ * - Intended primarily for debugging, tracing, or development diagnostics.
+ */
+exports.getInsertionIndex = getInsertionIndex;
+function log(level, ...args) {
+  try {
+    if (!cachedConfig.debug) return;
+    if (!cachedConfig.debug_levels && cachedConfig.debug_levels.length === 0) level = _constants.CASPER_LOG_TYPE_ERROR;
+    if (cachedConfig.debug_levels && cachedConfig.debug_levels.length > 0 && !cachedConfig.debug_levels.includes(level)) return;
+    const {
+      raw
+    } = formatMessage(level.toUpperCase(), args);
+    _fs.default.appendFileSync(_path.default.join(process.cwd(), _constants.CASPER_DEBUG_LOG_FILE_NAME), raw + "\n");
+    writeToConsole(level, raw);
+  } catch (e) {}
+}
+
+/**
+ * Determines whether a file should be processed or excluded by the transformation.
+ *
+ * This utility filters files based on predefined exclusion rules and optional
+ * source directory constraints.
+ *
+ * Exclusion Rules:
+ * - Files inside `node_modules` are excluded.
+ * - Files inside build output folders (e.g., `dist`, `build`) are excluded.
+ * - The global context file is excluded.
+ *
+ * Inclusion Rule:
+ * - If `opts.sourceDir` is provided, only files inside that directory
+ *   (relative to `opts.root` or `process.cwd()`) are included.
+ * - If `opts.sourceDir` is not provided, all non-excluded files are included.
+ *
+ * @param {string} file - Absolute or relative file path being evaluated.
+ * @param {Object} [opts] - Optional configuration object.
+ * @param {string} [opts.sourceDir] - Source directory to restrict processing.
+ * @param {string} [opts.root] - Project root directory. Defaults to `process.cwd()`.
+ *
+ * @returns {boolean}
+ * - `true` → File is allowed to be processed.
+ * - `false` → File should be excluded.
+ *
+ * @important
+ * - Path checks use simple string matching (`includes`, `startsWith`),
+ *   so paths should be normalized before calling this function if
+ *   cross-platform compatibility is required.
+ * - Ensure `file` is an absolute path when using `sourceDir` filtering
+ *   for accurate matching.
+ */
+function isExcludeFile(file, opts) {
+  try {
+    if (file.includes(_constants.NODE_MODULES)) return false;
+    if (file.includes(_constants.FOLDER_DIST) || file.includes(_constants.FOLDER_BUILD)) return false;
+    if (file.includes(_constants.GBL_CONTEXT_JS)) return false;
+    if (opts?.sourceDir) {
+      const root = opts.root || process.cwd();
+      const srcRoot = _path.default.join(root, opts.sourceDir);
+      return file.startsWith(srcRoot);
+    }
+    return true;
+  } catch (e) {
+    log('error', '[::isExcludeFile::]', e.message);
+  }
+}
+
+/**
+ * Resolves the React identifier to be used when generating AST nodes.
+ *
+ * This function determines which React reference should be used based on
+ * how React is imported in the current file.
+ *
+ * Resolution priority:
+ * 1. `state.importState.reactId`
+ *    - Covers:
+ *      - `import React from 'react'`
+ *      - `import * as React from 'react'`
+ * 2. Fallback to an injected global/core React identifier
+ *    - Used when no explicit React import exists in the file
+ *
+ * @param {NodePath} path - Current Babel path (not directly used, but kept for symmetry/future use).
+ * @param {Object} t - Babel types helper.
+ * @param {Object} state - Babel plugin state.
+ * @param {Object} state.importState - Collected import metadata.
+ * @param {Identifier} [state.importState.reactId] - Resolved React identifier, if imported.
+ *
+ * @returns {Identifier}
+ * The identifier representing `React` to be used in generated expressions
+ * (e.g. `React.createElement`, `React.useContext`).
+ *
+ * @important
+ * - This function does NOT validate whether the fallback React identifier
+ *   is actually in scope; callers must ensure it is injected if needed.
+ * - Hooks-only imports (`import { useState } from 'react'`) will NOT
+ *   populate `reactId`, so fallback behavior applies.
+ */
+function resolveReact(path, t, state) {
+  try {
+    const importState = state.importState;
+    let reactIdent;
+    // -------- React identifier --------
+    if (importState.reactId) {
+      // default OR namespace import
+      // import React from 'react'
+      // import * as React from 'react'
+      reactIdent = importState.reactId;
+    } else {
+      // fallback injected core react
+      reactIdent = t.identifier(_constants._CCTX_UNDUS_CORE_REACT);
+    }
+    return reactIdent;
+  } catch (e) {
+    log('error', '[::resolveReact::]', e.message);
+  }
+}
+
+/**
+ * Resets registered variable metadata for all virtual registry entries
+ * associated with a specific file hash.
+ *
+ * This function scans the provided `virtualRegistry` and clears the
+ * `varNames` and `defaults` collections for any registry entry whose key
+ * matches the given `fileHash` suffix. It is typically used when a file
+ * is reprocessed to ensure stale variable mappings do not persist.
+ *
+ * @param {Object<string, Object>} virtualRegistry - Central registry object that stores
+ * component/context mappings and variable metadata.
+ * @param {string} fileHash - Unique hash identifier representing the file.
+ * This hash is expected to be appended to registry keys using the format:
+ * `"<componentHash>_<fileHash>"`.
+ *
+ * @returns {void}
+ * This function mutates `virtualRegistry` in place and does not return a value.
+ *
+ * @important
+ * - Only registry entries whose keys end with `_<fileHash>` are affected.
+ * - The registry entry itself is NOT removed; only `varNames` and `defaults`
+ *   are cleared.
+ * - Safe to call multiple times; repeated calls will simply reset the same entries.
+ * - Assumes registry keys consistently follow the expected naming convention.
+ */
+function resetVarsForFile(virtualRegistry, fileHash) {
+  try {
+    for (const key of Object.keys(virtualRegistry)) {
+      if (key.endsWith(`_${fileHash}`)) {
+        virtualRegistry[key].varNames = [];
+        virtualRegistry[key].defaults = {};
+      }
+    }
+  } catch (e) {
+    log('error', '[::resetVarsForFile::]', e.message);
+  }
+}
+
+/**
+ * Reads, parses, and caches the Casper configuration file.
+ *
+ * This function loads user-defined configuration from the Casper config file
+ * located at `CASPER_CONFIG_PATH`. If the file exists and contains valid JSON,
+ * its values are merged with `DEFAULT_CONFIG`. The merged result is cached to
+ * avoid repeated filesystem reads and parsing during subsequent calls.
+ *
+ * If the config file does not exist or parsing fails, the function falls back
+ * to `DEFAULT_CONFIG`.
+ *
+ * @returns {Object}
+ * The resolved Casper configuration object, which is either:
+ * - A merged object of `DEFAULT_CONFIG` and user-provided config values, or
+ * - `DEFAULT_CONFIG` if no valid user configuration is found.
+ *
+ * @important
+ * - Configuration is cached after the first successful read to improve performance.
+ * - Subsequent calls return the cached configuration without re-reading the file.
+ * - If runtime config reloading is required, `cachedConfig` must be manually cleared.
+ * - User configuration values override matching keys in `DEFAULT_CONFIG`.
+ * - Invalid JSON or filesystem errors automatically trigger fallback to `DEFAULT_CONFIG`.
+ */
+let cachedConfig = null;
+function readCasperConfig() {
+  if (cachedConfig) return cachedConfig;
+  try {
+    if (_fs.default.existsSync(CASPER_CONFIG_PATH)) {
+      const file = _fs.default.readFileSync(CASPER_CONFIG_PATH, "utf8");
+      const userConfig = JSON.parse(file);
+      cachedConfig = {
+        ...DEFAULT_CONFIG,
+        ...userConfig
+      };
+    } else {
+      cachedConfig = DEFAULT_CONFIG;
+    }
+  } catch (e) {
+    cachedConfig = DEFAULT_CONFIG;
+  }
+  return cachedConfig;
+}
+
+/**
+ * Safely converts a value into a string representation.
+ *
+ * This utility ensures logging operations never fail due to
+ * circular references or non-serializable objects. If the
+ * value is already a string, it is returned as-is. Otherwise,
+ * the value is serialized using JSON.stringify().
+ *
+ * @param {any} value - The value to stringify.
+ *
+ * @returns {string} A safe string representation of the input value.
+ * Returns "[Unserializable Object]" if serialization fails.
+ *
+ * Behavior:
+ * - Prevents runtime crashes during logging.
+ * - Handles complex or circular objects gracefully.
+ * - Ensures consistent log output formatting.
+ */
+function safeStringify(value) {
+  try {
+    return typeof value === _constants.CASPER_STRING_TYPE ? value : JSON.stringify(value);
+  } catch {
+    return "[Unserializable Object]";
+  }
+}
+
+/**
+ * Formats log data into a standardized Casper log structure.
+ *
+ * This function builds a consistent log message by attaching
+ * the context namespace, log level, timestamp, and safely
+ * stringified message content.
+ *
+ * @param {string} level - Log severity level (e.g., INFO, WARN, ERROR, DEBUG, TRACE).
+ * @param {Array<any>} args - List of values to include in the log message.
+ * Values are safely converted to strings using `safeStringify`.
+ *
+ * @returns {Object} Formatted log object containing:
+ * @returns {string} returns.raw - Fully formatted log string ready for console/file output.
+ * @returns {string} returns.timestamp - ISO timestamp when the log was created.
+ * @returns {string} returns.message - Combined stringified message content.
+ *
+ * Behavior:
+ * - Ensures consistent log formatting across Casper logging system.
+ * - Prevents runtime crashes by safely serializing non-string values.
+ * - Centralizes log formatting for console and file writers.
+ */
+function formatMessage(level, args) {
+  try {
+    const timestamp = new Date().toISOString();
+    const message = args.map(safeStringify).join(" ");
+    return {
+      raw: `[${_constants.CONTEXT_NAMESPACE}][${level}][${timestamp}] ${message}`,
+      timestamp,
+      message
+    };
+  } catch (e) {}
+}
+
+/**
+ * Writes a formatted log message to the console with color styling.
+ *
+ * This function only outputs logs when Casper debug mode is enabled.
+ * It applies a color based on the log level to improve readability
+ * during development and debugging.
+ *
+ * @param {string} level - Log severity level (e.g., INFO, WARN, ERROR, DEBUG, TRACE).
+ * @param {string} text - Fully formatted log message to display.
+ *
+ * Behavior:
+ * - Skips console output if debug mode is disabled.
+ * - Falls back to INFO color if an unknown level is provided.
+ * - Resets console color after logging to prevent style bleeding.
+ */
+function writeToConsole(level, text) {
+  try {
+    if (!cachedConfig.debug) return;
+    const color = _constants.COLORS[level.toLowerCase()] || _constants.COLORS.info;
+    console.log(`${color}${text}${_constants.COLORS.reset}`);
+  } catch (e) {}
+}