binary-collections 2.0.3 → 2.0.6

package/lib/ps/table-parser.js

@@ -0,0 +1,359 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/ps/connected-domain.js
+var require_connected_domain = __commonJS({
+  "src/ps/connected-domain.js"(exports2, module2) {
+    init_cjs_shims();
+    module2.exports = function(tdArray, indicator, hardlink) {
+      hardlink = hardlink || false;
+      if (!tdArray) {
+        throw new Error("tdArray must be provided");
+      }
+      if (!indicator) {
+        throw new Error("indicator must be provided");
+      }
+      tdArray = JSON.parse(JSON.stringify(tdArray));
+      var domains = {};
+      var domainUUID = 0;
+      var pointsHash = {};
+      tdArray.forEach(function(row, y) {
+        row.forEach(function(colItem, x) {
+          var identifier2 = indicator(colItem, x, y);
+          var neighbours = [];
+          if (tdArray[y - 1] && tdArray[y - 1][x] !== void 0) {
+            neighbours.push(pointsHash[x + "_" + (y - 1)]);
+          }
+          if (row[x - 1] !== void 0) {
+            neighbours.push(pointsHash[x - 1 + "_" + y]);
+          }
+          if (!hardlink) {
+            if (tdArray[y - 1] && tdArray[y - 1][x - 1] !== void 0) {
+              neighbours.push(pointsHash[x - 1 + "_" + (y - 1)]);
+            }
+            if (tdArray[y - 1] && tdArray[y - 1][x + 1] !== void 0) {
+              neighbours.push(pointsHash[x + 1 + "_" + (y - 1)]);
+            }
+          }
+          if (neighbours.length) {
+            var matched = false;
+            neighbours.forEach(function(neighbour) {
+              if (neighbour.identifier == identifier2) {
+                if (!matched) {
+                  addPointToDomain(colItem, x, y, neighbour.domainId);
+                  matched = true;
+                } else {
+                  var colItemPoint = pointsHash[x + "_" + y];
+                  if (neighbour.domainId != colItemPoint.domainId) {
+                    mergeDomains(neighbour.domainId, colItemPoint.domainId);
+                  }
+                }
+              }
+            });
+            if (!matched) {
+              addNewDomain(colItem, x, y, identifier2);
+            }
+          } else {
+            addNewDomain(colItem, x, y, identifier2);
+          }
+        });
+      });
+      var result = {
+        domains: [],
+        totalDomains: 0,
+        groupByIdentifier: {},
+        totalIdentifiers: 0
+      };
+      var domainId = null;
+      var identifier = null;
+      var domain = null;
+      for (domainId in domains) {
+        domain = domains[domainId];
+        domain.bounding = calculateBounding(domain.points);
+        identifier = domain.identifier;
+        result.domains.push(domain);
+        result.totalDomains++;
+        if (!(identifier in result.groupByIdentifier)) {
+          result.groupByIdentifier[identifier] = [];
+          result.totalIdentifiers++;
+        }
+        result.groupByIdentifier[identifier].push(domain);
+      }
+      function calculateBounding(points) {
+        var minX = null;
+        var minY = null;
+        var maxX = null;
+        var maxY = null;
+        points.forEach(function(point) {
+          if (minX === null || point.x < minX) {
+            minX = point.x;
+          }
+          if (minY === null || point.y < minY) {
+            minY = point.y;
+          }
+          if (maxX === null || point.x > maxX) {
+            maxX = point.x;
+          }
+          if (maxY === null || point.y > maxY) {
+            maxY = point.y;
+          }
+        });
+        var w = maxX - minX;
+        var h = maxY - minY;
+        return {
+          x: minX,
+          y: minY,
+          w,
+          h
+        };
+      }
+      function addNewDomain(point, x, y, identifier2) {
+        var newDomain = {
+          identifier: identifier2,
+          domainId: ++domainUUID,
+          bounding: {},
+          points: []
+        };
+        var newPoint = {
+          value: point,
+          x,
+          y,
+          identifier: identifier2,
+          domainId: newDomain.domainId
+        };
+        pointsHash[x + "_" + y] = {
+          value: point,
+          identifier: identifier2,
+          domainId: newDomain.domainId
+        };
+        newDomain.points.push(newPoint);
+        domains[newDomain.domainId] = newDomain;
+      }
+      function addPointToDomain(point, x, y, domainId2) {
+        var domain2 = domains[domainId2];
+        var newPoint = {
+          value: point,
+          x,
+          y,
+          identifier: domain2.identifier,
+          domainId: domainId2
+        };
+        pointsHash[x + "_" + y] = {
+          value: point,
+          identifier: domain2.identifier,
+          domainId: domainId2
+        };
+        domain2.points.push(newPoint);
+      }
+      function mergeDomains(domainAId, domainBId) {
+        var domainA = domains[domainAId];
+        var domainB = domains[domainBId];
+        if (domainA.identifier == domainB.identifier) {
+          domainB.domainId = domainA.domainId;
+          domainB.points.forEach(function(point) {
+            point.domainId = domainA.domainId;
+            pointsHash[point.x + "_" + point.y].domainId = domainA.domainId;
+          });
+          domainA.points = domainA.points.concat(domainB.points);
+          delete domains[domainBId];
+        }
+      }
+      return result;
+    };
+  }
+});
+
+// src/ps/table-parser.js
+init_cjs_shims();
+var ConnectedDomain = require_connected_domain();
+var EMPTY_EX = /\s/;
+module.exports.parse = function(output) {
+  var linesTmp = output.split(/(\r\n)|(\n\r)|\n|\r/);
+  var lines = [];
+  var titleInfo = {};
+  var twoDimArray = [];
+  linesTmp.forEach(function(line) {
+    if (line && line.trim()) {
+      lines.push(line);
+    }
+  });
+  lines.forEach(function(line, index) {
+    if (index == 0) {
+      var fields = line.split(/\s+/);
+      var currentIndex = 0;
+      fields.forEach(function(field, idx) {
+        if (field) {
+          var info = titleInfo[field] = {};
+          var indexBegin = line.indexOf(field, currentIndex);
+          var indexEnd = currentIndex = indexBegin + field.length;
+          if (idx == 0) {
+            info.titleBegin = 0;
+          } else {
+            info.titleBegin = indexBegin;
+          }
+          if (idx == fields.length - 1) {
+            info.titleEnd = line.length - 1;
+          } else {
+            info.titleEnd = indexEnd;
+          }
+        }
+      });
+    } else {
+      twoDimArray[index - 1] = line.split("");
+    }
+  });
+  var connectedDomains = ConnectedDomain(
+    twoDimArray,
+    function(value) {
+      if (EMPTY_EX.test(value)) {
+        return -1;
+      } else {
+        return 1;
+      }
+    },
+    true
+  );
+  var valuesDomainsVerticalGroups = [];
+  connectedDomains.domains.sort(function(a, b) {
+    return a.bounding.x - b.bounding.x;
+  });
+  connectedDomains.domains.forEach(function(domain) {
+    if (domain.identifier === 1) {
+      var overlapped = false;
+      valuesDomainsVerticalGroups.forEach(function(group) {
+        var bounding = domain.bounding;
+        var left = bounding.x;
+        var right = bounding.x + bounding.w;
+        if (overlap(left, right, group.begin, group.end)) {
+          overlapped = true;
+          group.domains.push(domain);
+          group.begin = group.begin > left ? left : group.begin;
+          group.end = group.end < right ? right : group.end;
+        }
+      });
+      if (!overlapped) {
+        valuesDomainsVerticalGroups.push({
+          begin: domain.bounding.x,
+          end: domain.bounding.x + domain.bounding.w,
+          domains: [domain]
+        });
+      }
+    }
+  });
+  valuesDomainsVerticalGroups.forEach(function(group) {
+    var title = null;
+    var info = null;
+    var overlapped = false;
+    var minimunLeftDistance = null;
+    var nearestLeftTitle = null;
+    var distance = null;
+    for (title in titleInfo) {
+      info = titleInfo[title];
+      if (group.begin > info.titleBegin) {
+        distance = group.begin - info.titleBegin;
+        if (!nearestLeftTitle || distance < minimunLeftDistance) {
+          nearestLeftTitle = title;
+          minimunLeftDistance = distance;
+        }
+      }
+      if (overlap(group.begin, group.end, info.titleBegin, info.titleEnd)) {
+        overlapped = true;
+        info.titleBegin = info.titleBegin > group.begin ? group.begin : info.titleBegin;
+        info.titleEnd = info.titleEnd < group.end ? group.end : info.titleEnd;
+      }
+    }
+    if (!overlapped && nearestLeftTitle) {
+      var nearestTitleField = titleInfo[nearestLeftTitle];
+      nearestTitleField.titleBegin = nearestTitleField.titleBegin > group.begin ? group.begin : nearestTitleField.titleBegin;
+      nearestTitleField.titleEnd = nearestTitleField.titleEnd < group.end ? group.end : nearestTitleField.titleEnd;
+    }
+  });
+  var result = [];
+  lines.forEach(function(line, index) {
+    if (index > 0) {
+      var lineItem = {};
+      var title = null;
+      var info = null;
+      var value = null;
+      for (title in titleInfo) {
+        info = titleInfo[title];
+        value = line.substring(info.titleBegin, info.titleEnd + 1);
+        lineItem[title] = splitValue(value.trim());
+      }
+      result.push(lineItem);
+    }
+  });
+  return result;
+};
+function overlap(begin1, end1, begin2, end2) {
+  return begin1 > begin2 && begin1 < end2 || // 2--1--2--1 or 2--1--1--2
+  end1 > begin2 && end1 < end2 || // 1--2--1--2 or 2--1--1--2
+  begin1 <= begin2 && end1 >= end2;
+}
+function splitValue(value) {
+  var match = value.match(/"/g);
+  if (!match || match.length == 1) {
+    return value.split(/\s+/);
+  } else {
+    var result = [];
+    var chunk = null;
+    var ifInWrappedChunk = false;
+    var ifInPureWrappedChunk = false;
+    var quotaCount = 0;
+    var maxQuotaCount = match.length % 2 == 0 ? match.length : match.length - 1;
+    var previousItem = null;
+    var values = value.split("");
+    values.forEach(function(item, index) {
+      if (item !== " ") {
+        if (item === '"') {
+          if (ifInWrappedChunk === false && quotaCount <= maxQuotaCount) {
+            ifInWrappedChunk = true;
+            quotaCount++;
+            if (previousItem === " " || previousItem === null) {
+              ifInPureWrappedChunk = true;
+              chunk = "";
+            } else {
+              chunk += item;
+            }
+          } else if (ifInWrappedChunk === true) {
+            ifInWrappedChunk = false;
+            quotaCount++;
+            if (ifInPureWrappedChunk === true) {
+              ifInPureWrappedChunk = false;
+              result.push(chunk);
+              chunk = null;
+            } else {
+              chunk += item;
+            }
+          }
+        } else if (ifInWrappedChunk === false && (previousItem === " " || previousItem === null)) {
+          chunk = item;
+        } else {
+          chunk += item;
+        }
+      } else if (ifInWrappedChunk) {
+        chunk += item;
+      } else if (chunk !== null) {
+        result.push(chunk);
+        chunk = null;
+      }
+      previousItem = item;
+      if (index == values.length - 1 && chunk !== null) {
+        result.push(chunk);
+        chunk = null;
+      }
+    });
+    return result;
+  }
+}

package/lib/ps/table-parser.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_table_parser
+} from "../chunk-GA4DDV65.mjs";
+import "../chunk-M4IBUK4H.mjs";
+import "../chunk-7MSZ52XC.mjs";
+import "../chunk-AVDT32AY.mjs";
+export default require_table_parser();

package/lib/utils.cjs

@@ -0,0 +1,35 @@
+// src/utils.js
+var { fs, path } = require("sbg-utility");
+var argv = require("minimist")(process.argv.slice(2));
+function getArgs() {
+  return argv;
+}
+function delStream(globStream) {
+  globStream.stream().on("data", (result) => {
+    const fullPath = path.resolve(process.cwd(), result);
+    if (fs.statSync(fullPath).isDirectory()) {
+      const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+      for (let i = 0; i < subdir.length; i++) {
+        del(subdir[i]);
+      }
+    }
+    del(fullPath);
+  });
+}
+function del(fullPath) {
+  if (fs.statSync(fullPath).isDirectory()) {
+    const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+    for (let i = 0; i < subdir.length; i++) {
+      del(subdir[i]);
+    }
+  } else {
+    try {
+      fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+      console.log("deleted", fullPath);
+    } catch (_) {
+      console.log("failed delete", fullPath);
+    }
+  }
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+module.exports = { del, delStream, getArgs, delay };

package/lib/utils.d.mts

@@ -0,0 +1,20 @@
+import * as minimist from 'minimist';
+
+/**
+ * delete file recursive
+ * @param {string} fullPath
+ */
+declare function del(fullPath: string): void;
+/**
+ * glob stream handler
+ * @param {glob.Glob} globStream
+ */
+declare function delStream(globStream: glob.Glob): void;
+declare function getArgs(): minimist.ParsedArgs;
+/**
+ * async delayed
+ * @param {number} ms
+ */
+declare function delay(ms: number): Promise<any>;
+
+export { del, delStream, delay, getArgs };

package/lib/utils.d.ts

@@ -0,0 +1,20 @@
+import * as minimist from 'minimist';
+
+/**
+ * delete file recursive
+ * @param {string} fullPath
+ */
+declare function del(fullPath: string): void;
+/**
+ * glob stream handler
+ * @param {glob.Glob} globStream
+ */
+declare function delStream(globStream: glob.Glob): void;
+declare function getArgs(): minimist.ParsedArgs;
+/**
+ * async delayed
+ * @param {number} ms
+ */
+declare function delay(ms: number): Promise<any>;
+
+export { del, delStream, delay, getArgs };

package/lib/utils.js

@@ -0,0 +1,35 @@
+// src/utils.js
+var { fs, path } = require("sbg-utility");
+var argv = require("minimist")(process.argv.slice(2));
+function getArgs() {
+  return argv;
+}
+function delStream(globStream) {
+  globStream.stream().on("data", (result) => {
+    const fullPath = path.resolve(process.cwd(), result);
+    if (fs.statSync(fullPath).isDirectory()) {
+      const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+      for (let i = 0; i < subdir.length; i++) {
+        del(subdir[i]);
+      }
+    }
+    del(fullPath);
+  });
+}
+function del(fullPath) {
+  if (fs.statSync(fullPath).isDirectory()) {
+    const subdir = fs.readdirSync(fullPath).map((dirPath) => path.resolve(fullPath, dirPath));
+    for (let i = 0; i < subdir.length; i++) {
+      del(subdir[i]);
+    }
+  } else {
+    try {
+      fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+      console.log("deleted", fullPath);
+    } catch (_) {
+      console.log("failed delete", fullPath);
+    }
+  }
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+module.exports = { del, delStream, getArgs, delay };

package/lib/utils.mjs

@@ -0,0 +1,7 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-LPLPQBYP.mjs";
+import "./chunk-7MSZ52XC.mjs";
+import "./chunk-AVDT32AY.mjs";
+export default require_utils();

package/package.json

@@ -1,57 +1,83 @@
 {
   "name": "binary-collections",
-  "version": "2.0.3",
-  "description": "binary helper collections by L3n4r0x",
+  "version": "2.0.6",
+  "description": "Utility to clean any programming caches and more",
   "main": "index.js",
   "files": [
     "bin",
     "lib",
     "index.js",
-    "!releases"
+    "!test",
+    "package.json"
   ],
   "directories": {
-    "lib": "lib",
-    "test": "test"
+    "lib": "lib"
   },
   "scripts": {
     "update:packer": "curl -L https://github.com/dimaslanjaka/nodejs-package-types/raw/main/packer.js > packer.js",
-    "build": "node -r ts-node/register -r dotenv/config build.js && yarn run pack",
+    "build": "node build.tsup.js && npm run postbuild",
+    "postbuild": "node -r ts-node/register -r dotenv/config build.js && yarn run pack",
     "test": "cd test && npm install -D file:../ &&",
     "test:nrs": "npm test -- nrs build:**",
     "pack": "node packer.js --yarn --filename=bin",
-    "update:ncu": "npx npm-check-updates -u -x jsdom,chalk,hexo,deepmerge-ts --enginesNode --root"
+    "update:ncu": "npx npm-check-updates -u -x jsdom,chalk,hexo,deepmerge-ts --enginesNode --root",
+    "clean": "rimraf lib"
   },
-  "keywords": [],
-  "author": "",
+  "keywords": [
+    "cache",
+    "cleaner",
+    "utility"
+  ],
+  "author": {
+    "email": "dimaslanjaka@gmail.com",
+    "name": "dimaslanjaka",
+    "url": "https://webmanajemen.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dimaslanjaka/bin"
+  },
+  "bugs": {
+    "url": "https://github.com/dimaslanjaka/bin/issues"
+  },
+  "homepage": "https://www.webmanajemen.com/",
   "license": "MIT",
   "dependencies": {
-    "execa": "^8.0.1",
+    "dotenv": "^16.4.5",
+    "execa": "^9.4.0",
     "fs-extra": "^11.2.0",
-    "glob": "^10.3.10",
-    "minimatch": "^9.0.3",
+    "glob": "^11.0.0",
+    "minimatch": "^10.0.1",
     "minimist": "^1.2.8",
-    "sbg-utility": "^1.1.6",
+    "ps-node": "^0.1.6",
+    "remove": "^0.1.5",
+    "sbg-utility": "^1.1.8",
     "upath": "^2.0.1",
-    "yaml": "^2.3.4"
+    "yaml": "^2.5.1",
+    "yarn": "^1.22.22"
   },
-  "packageManager": "yarn@3.6.1",
+  "packageManager": "yarn@4.5.0",
   "devDependencies": {
-    "@types/eslint": "^8",
+    "@types/eslint": "^9",
+    "@types/fs-extra": "^11.0.4",
     "@types/minimist": "^1",
-    "@types/node": "^20.11.16",
+    "@types/node": "^22.7.4",
     "@types/prettier": "^3",
+    "@types/ps-node": "^0",
     "@types/yargs": "^17",
-    "@typescript-eslint/eslint-plugin": "^6.20.0",
-    "@typescript-eslint/parser": "^6.20.0",
-    "cross-spawn": "https://github.com/dimaslanjaka/node-cross-spawn/raw/ff4b648/release/cross-spawn.tgz",
-    "dotenv": "^16.4.1",
-    "eslint": "^8.56.0",
+    "@typescript-eslint/eslint-plugin": "^8.8.0",
+    "@typescript-eslint/parser": "^8.8.0",
+    "cross-spawn": "https://github.com/dimaslanjaka/node-cross-spawn/raw/private/release/cross-spawn.tgz",
+    "eslint": "^9.11.1",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-prettier": "^5.2.1",
     "git-command-helper": "^2.0.2",
-    "prettier": "^3.2.4",
+    "globals": "^15.10.0",
+    "prettier": "^3.3.3",
+    "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2"
   },
   "optionalDependencies": {
     "ansi-colors": "^4.1.3"
@@ -59,29 +85,60 @@
   "bin": {
     "clean-nodemodule": "bin/clean-nodemodule",
     "clean-nodemodules": "bin/clean-nodemodules",
-    "del-nodemodules": "lib/del-nodemodules.js",
+    "connected-domain-cjs": "lib/ps/connected-domain.cjs",
+    "connected-domain-mjs": "lib/ps/connected-domain.mjs",
+    "del-gradle": "lib/del-gradle.cjs",
+    "del-gradle-cjs": "lib/del-gradle.cjs",
+    "del-gradle-mjs": "lib/del-gradle.mjs",
+    "del-node-modules-cjs": "lib/del-node-modules.cjs",
+    "del-node-modules-mjs": "lib/del-node-modules.mjs",
+    "del-nodemodules": "lib/del-node-modules.cjs",
+    "del-ps": "lib/del-ps.cjs",
+    "del-ps-cjs": "lib/del-ps.cjs",
+    "del-ps-mjs": "lib/del-ps.mjs",
+    "del-yarn-caches-cjs": "lib/del-yarn-caches.cjs",
+    "del-yarn-caches-mjs": "lib/del-yarn-caches.mjs",
+    "del-yarncaches": "lib/del-yarn-caches.cjs",
     "dev": "bin/dev",
     "empty": "bin/empty",
-    "find-nodemodules": "lib/find-nodemodules.js",
+    "eslint-config-cjs": "eslint.config.cjs",
+    "find-node-modules-cjs": "lib/find-node-modules.cjs",
+    "find-node-modules-mjs": "lib/find-node-modules.mjs",
+    "find-nodemodules": "lib/find-node-modules.cjs",
     "git-fix-encoding": "bin/git-fix-encoding",
     "git-fix-encoding-cmd": "bin/git-fix-encoding.cmd",
+    "git-purge": "lib/git-purge.cjs",
+    "git-purge-cjs": "lib/git-purge.cjs",
+    "git-purge-mjs": "lib/git-purge.mjs",
     "git-reduce-size": "bin/git-reduce-size",
+    "index-cjs": "lib/ps/index.cjs",
+    "index-mjs": "lib/ps/index.mjs",
+    "isWin-cjs": "lib/ps/isWin.cjs",
+    "isWin-mjs": "lib/ps/isWin.mjs",
     "javakill-cmd": "bin/javakill.cmd",
     "kill-process": "bin/kill-process",
     "nodekill": "bin/nodekill",
     "nodekill-cmd": "bin/nodekill.cmd",
     "nodekill-ps1": "bin/nodekill.ps1",
-    "npm-run-series": "lib/npm-run-series.js",
-    "nrs": "lib/npm-run-series.js",
+    "npm-run-series": "lib/npm-run-series.cjs",
+    "npm-run-series-cjs": "lib/npm-run-series.cjs",
+    "npm-run-series-mjs": "lib/npm-run-series.mjs",
+    "nrs": "lib/npm-run-series.cjs",
+    "package-resolutions-cjs": "lib/package-resolutions.cjs",
+    "package-resolutions-mjs": "lib/package-resolutions.mjs",
     "prod": "bin/prod",
     "rmfind": "bin/rmfind",
     "rmpath": "bin/rmpath",
     "rmx": "bin/rmx",
-    "run-s": "lib/npm-run-series.js",
-    "run-series": "lib/npm-run-series.js",
+    "run-s": "lib/npm-run-series.cjs",
+    "run-series": "lib/npm-run-series.cjs",
     "submodule": "bin/submodule",
     "submodule-install": "bin/submodule-install",
     "submodule-remove": "bin/submodule-remove",
-    "submodule-token": "bin/submodule-token"
+    "submodule-token": "bin/submodule-token",
+    "table-parser-cjs": "lib/ps/table-parser.cjs",
+    "table-parser-mjs": "lib/ps/table-parser.mjs",
+    "utils-cjs": "lib/utils.cjs",
+    "utils-mjs": "lib/utils.mjs"
   }
 }