[PROCESS RERUN]: remove utils

Author: potapovDim

lib/executor.circle.ts

@@ -91,11 +91,18 @@ async function circleExecutor(runOptions, commandsArray): Promise<{ retriable: s
 
     const asserter = setInterval(() => runCommand(commands, retriable, executionCount), pollTime);
 
-    const logProcessesProgressLogger =
-      logProcessesProgress &&
-      setInterval(() => logMiddleResultsCycle(initialCommandsCount, commands, inProgressCommands), 5000);
-
-    const watcherRunner = watcher && setInterval(() => watcher(Array.from(notRetriable), Array.from(retriable)), 5000);
+    const watcherRunner =
+      watcher &&
+      setInterval(
+        () =>
+          watcher({
+            notRetriable: Array.from(notRetriable),
+            retriable: Array.from(retriable),
+            inProgressCommands: Array.from(inProgressCommands),
+            initialCommandsCount,
+          }),
+        5000,
+      );
 
     do {
       if (commands.length) {
@@ -114,10 +121,6 @@ async function circleExecutor(runOptions, commandsArray): Promise<{ retriable: s
       }
     }
 
-    if (logProcessesProgressLogger) {
-      clearInterval(logProcessesProgressLogger);
-    }
-
     if (watcherRunner) {
       clearInterval(watcherRunner);
     }

lib/executor.intime.ts

@@ -1,15 +1,15 @@
-import { shuffleArrMutable, isString, isFunction, isAsyncFunction } from 'sat-utils';
+import { isString, isFunction, isAsyncFunction } from 'sat-utils';
 import { buildCommandExecutor } from './command.executor.builder';
 import { sleep } from './helpers';
 import { logger } from './logger';
-import {
-  internalLogStartCycle,
-  internalLogEndCycle,
-  internalLogMiddleResultsCycle,
-  internalLogIntimeCommand,
-} from './logger.execution';
-
-async function intimeExecutor(runOptions, commandsArray): Promise<{ retriable: string[]; notRetriable: string[] }> {
+import { internalLogStartCycle, internalLogEndCycle, internalLogIntimeCommand } from './logger.execution';
+
+import type { TBuildOpts } from './lib.types';
+
+async function intimeExecutor(
+  runOptions: TBuildOpts,
+  commandsArray,
+): Promise<{ retriable: string[]; notRetriable: string[] }> {
   const notRetriable = [];
   const retriable = [];
 
@@ -23,12 +23,9 @@ async function intimeExecutor(runOptions, commandsArray): Promise<{ retriable: s
     successExitCode,
     currentExecutionVariable,
     maxThreads,
-    shuffle,
     watcher,
-    logProcessesProgress,
     logStartCycle = internalLogStartCycle,
     logEndCycle = internalLogEndCycle,
-    logMiddleResultsCycle = internalLogMiddleResultsCycle,
     logIntimeCommand = internalLogIntimeCommand,
     execOpts,
   } = runOptions;
@@ -53,9 +50,7 @@ async function intimeExecutor(runOptions, commandsArray): Promise<{ retriable: s
   async function runCommand(commands) {
     if (maxThreads > currentSessionCount && commands.length) {
       currentSessionCount += 1;
-      if (shuffle) {
-        shuffleArrMutable(commands);
-      }
+
       let result;
       const commadData = commands.splice(0, 1)[0] as { cmd; attemptsCount: number };
 
@@ -90,11 +85,18 @@ async function intimeExecutor(runOptions, commandsArray): Promise<{ retriable: s
     const initialCommandsCount = commands.length;
     const asserter = setInterval(() => runCommand(commands), pollTime);
 
-    const logProcessesProgressLoggerRunner =
-      logProcessesProgress &&
-      setInterval(() => logMiddleResultsCycle(initialCommandsCount, commands, inProgressCommands), 5000);
-
-    const watcherRunner = watcher && setInterval(() => watcher(Array.from(notRetriable), Array.from(retriable)), 5000);
+    const watcherRunner =
+      watcher &&
+      setInterval(
+        () =>
+          watcher({
+            notRetriable: Array.from(notRetriable),
+            retriable: Array.from(retriable),
+            inProgressCommands: Array.from(inProgressCommands),
+            initialCommandsCount,
+          }),
+        5000,
+      );
 
     do {
       if (commands.length) {
@@ -109,9 +111,7 @@ async function intimeExecutor(runOptions, commandsArray): Promise<{ retriable: s
     );
 
     clearInterval(asserter);
-    if (logProcessesProgressLoggerRunner) {
-      clearInterval(logProcessesProgressLoggerRunner);
-    }
+
     if (watcherRunner) {
       clearInterval(watcherRunner);
     }

lib/helpers.ts

@@ -1,41 +1,3 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { ProcessRerunError } from './error';
-
-const getFilesList = function (
-  dir: string,
-  fileList: string[] = [],
-  directoryToSkip: string[] = [],
-  ignoreSubDirs?: boolean,
-): string[] {
-  if (!fs.existsSync(dir)) {
-    throw new ProcessRerunError('FileSystem', `${dir} does not exists`);
-  }
-
-  const files = fs.readdirSync(dir);
-
-  files.forEach(function (file) {
-    const isDirr = fs.statSync(path.join(dir, file)).isDirectory();
-
-    const shouldBeExcluded =
-      (Array.isArray(directoryToSkip) && directoryToSkip.includes(file)) ||
-      (typeof directoryToSkip === 'string' && file.includes(directoryToSkip)) ||
-      (directoryToSkip instanceof RegExp && file.match(directoryToSkip));
-
-    if (shouldBeExcluded) {
-      return;
-    }
-
-    if (isDirr && !ignoreSubDirs) {
-      fileList = getFilesList(path.join(dir, file), fileList, directoryToSkip, ignoreSubDirs);
-    } else if (!isDirr) {
-      fileList.push(path.join(dir, file));
-    }
-  });
-
-  return fileList;
-};
-
 function getPollTime(timeVal: any): number {
   return typeof timeVal === 'number' && !Number.isNaN(timeVal) && Number.isFinite(timeVal) ? timeVal : 1000;
 }
@@ -44,4 +6,4 @@ function sleep(time: number): Promise<void> {
   return new Promise(res => setTimeout(res, time));
 }
 
-export { getPollTime, sleep, getFilesList };
+export { getPollTime, sleep };

lib/index.ts

@@ -2,7 +2,8 @@ import { logger } from 'sat-utils';
 import { getPollTime } from './helpers';
 import { circleExecutor } from './executor.circle';
 import { intimeExecutor } from './executor.intime';
-import type { ExecOptions } from 'child_process';
+
+import type { TBuildOpts } from './lib.types';
 
 function reRunnerBuilder(runOptions) {
   const { logLevel = 'ERROR', intime = false, ...executorOptions } = runOptions;
@@ -12,28 +13,6 @@ function reRunnerBuilder(runOptions) {
   return intime ? intimeExecutor.bind(this, executorOptions) : circleExecutor.bind(this, executorOptions);
 }
 
-export type TBuildOpts = {
-  logLevel?: 'ERROR' | 'WARN' | 'INFO' | 'VERBOSE' | 'MUTE';
-  maxThreads?: number;
-  attemptsCount?: number;
-  longestProcessTime?: number;
-  successExitCode?: number;
-  pollTime?: number;
-  execOpts?: ExecOptions;
-  processResultAnalyzer?: (originalCommand: string, stack: string, notRetriable: any[]) => string | boolean;
-  everyCycleCallback?: () => void;
-  watcher?: (notRetriable?: string[], retriable?: string[]) => void;
-  currentExecutionVariable?: string;
-  logProcessesProgress?: boolean;
-  logStartCycle?: (maxThreads: number | string, attemptsCount: number | string, inTimeCommands: string[]) => void;
-  logEndCycle?: (retriable: string[], notRetriable: string[], startTime: number) => void;
-  logIteractionCycle?: (cycleNumber: number, commands: string[]) => void;
-  logMiddleResultsCycle?: (initialCount: number, commands: string[], commandsInProgressArr: string[]) => void;
-  logProcessResult?: (cmd: string, startTime: number, execProc, error, stdout, stderr) => void;
-  onExitCloseProcess?: (execProc, code: null, signal: string | number) => void;
-  onErrorProcess?: (execProc, error) => void;
-};
-
 export type TRunner = {
   (commands: string[] | Array<(index: number) => any>): Promise<{ notRetriable: string[]; retriable: string[] }>;
 };
@@ -58,6 +37,5 @@ const getReruner = ({
   return reRunnerBuilder(reformattedArgs);
 };
 
+export type { TBuildOpts } from './lib.types';
 export { getReruner };
-
-export { getFilesList } from './helpers';

lib/lib.types.d.ts

@@ -0,0 +1,27 @@
+import type { ExecOptions } from 'child_process';
+
+export type TBuildOpts = {
+  logLevel?: 'ERROR' | 'WARN' | 'INFO' | 'VERBOSE' | 'MUTE';
+  maxThreads?: number;
+  attemptsCount?: number;
+  longestProcessTime?: number;
+  successExitCode?: number;
+  pollTime?: number;
+  execOpts?: ExecOptions;
+  processResultAnalyzer?: (originalCommand: string, stack: string, notRetriable: any[]) => string | boolean;
+  everyCycleCallback?: () => void;
+  watcher?: (data: {
+    notRetriable?: string[];
+    retriable?: string[];
+    inProgressCommands?: string[];
+    initialCommandsCount?: number;
+  }) => void;
+  currentExecutionVariable?: string;
+  logStartCycle?: (maxThreads: number | string, attemptsCount: number | string, inTimeCommands: string[]) => void;
+  logEndCycle?: (retriable: string[], notRetriable: string[], startTime: number) => void;
+  logIteractionCycle?: (cycleNumber: number, commands: string[]) => void;
+  logProcessResult?: (cmd: string, startTime: number, execProc, error, stdout, stderr) => void;
+  onExitCloseProcess?: (execProc, code: null, signal: string | number) => void;
+  onErrorProcess?: (execProc, error) => void;
+  logIntimeCommand?: (commadData: { cmd: string; attemptsCount: number }) => void;
+};

package.json

@@ -1,16 +1,24 @@
 {
   "name": "process-rerun",
-  "version": "0.5.0",
+  "version": "1.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/potapovDim/protractor-rerun.git"
   },
-  "main": "./built/index.js",
+  "main": "./built/cjs/index.js",
+  "exports": {
+    ".": {
+      "require": "./built/cjs/index.js",
+      "import": "./built/esm/index.js"
+    }
+  },
   "scripts": {
     "tscw": "tsc -w",
     "validate": "npm ls",
     "test": "mocha $(find specs -name '*.spec.*') --timeout 500000 --require ts-node/register",
-    "tsc": "rm -rf ./built && tsc",
+    "tsc:cjs": "tsc -p tsconfig.json",
+    "tsc:esm": "tsc -p tsconfig.esm.json",
+    "tsc": "rm -rf ./built && npm run tsc:cjs && npm run tsc:esm",
     "lint": "eslint --ext .ts ./ --fix"
   },
   "author": {
@@ -32,7 +40,7 @@
   ],
   "devDependencies": {
     "@types/mocha": "^9.1.1",
-    "@types/node": "^14.17.1",
+    "@types/node": "^22.14.1",
     "@typescript-eslint/eslint-plugin": "^5.21.0",
     "@typescript-eslint/parser": "^5.21.0",
     "assertior": "0.0.11",
@@ -45,14 +53,14 @@
     "eslint-plugin-sonarjs": "^0.13.0",
     "eslint-plugin-unicorn": "^42.0.0",
     "mocha": "^10.0.0",
-    "ts-node": "^5.0.1",
+    "ts-node": "^10.9.1",
     "tslint": "^5.9.1",
-    "typescript": "^4.3.2"
+    "typescript": "^5.0.4"
   },
   "engines": {
-    "node": ">=10.22.0"
+    "node": ">=19.22.0"
   },
   "dependencies": {
     "sat-utils": "0.0.49"
   }
-}
+}