binary-collections 2.0.5 → 2.0.7

package/lib/chunk-4LEXWIIF.mjs

@@ -0,0 +1,173 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-VXZQNLPU.mjs";
+import {
+  __commonJS
+} from "./chunk-FB6YIQYR.mjs";
+
+// src/ps/connected-domain.js
+var require_connected_domain = __commonJS({
+  "src/ps/connected-domain.js"(exports, module) {
+    init_esm_shims();
+    module.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;
+    };
+  }
+});
+
+export {
+  require_connected_domain
+};

package/lib/chunk-BSD5CIRU.mjs

@@ -0,0 +1,52 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-VXZQNLPU.mjs";
+import {
+  __commonJS,
+  __require
+} from "./chunk-FB6YIQYR.mjs";
+
+// src/find-node-modules.js
+var require_find_node_modules = __commonJS({
+  "src/find-node-modules.js"(exports, module) {
+    init_esm_shims();
+    var glob = __require("glob");
+    var path = __require("path");
+    function findNodeModules(dir = process.cwd(), callback = null) {
+      const finalDir = typeof dir === "string" ? dir : process.cwd();
+      return new Promise((resolve, reject) => {
+        const results = [];
+        const g3 = new glob.Glob("**/node_modules", {
+          withFileTypes: false,
+          cwd: finalDir,
+          ignore: ["**/.git*", "**/vendor/**"]
+        });
+        const stream = g3.stream();
+        stream.on("data", (result) => {
+          const fullPath = path.resolve(finalDir, result);
+          if (typeof callback === "function") {
+            try {
+              callback(fullPath);
+            } catch (err) {
+              console.error("findNodeModules callback error:", err);
+            }
+          }
+          results.push(fullPath);
+        });
+        stream.on("error", (err) => reject(err));
+        stream.on("end", () => {
+          if (results.length === 0) {
+            console.log("No node_modules directories found.");
+          }
+          resolve(results);
+        });
+      });
+    }
+    module.exports = findNodeModules;
+  }
+});
+
+export {
+  require_find_node_modules
+};

package/lib/chunk-FB6YIQYR.mjs

@@ -0,0 +1,42 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __toESM
+};

package/lib/chunk-JL32QDSH.mjs

@@ -0,0 +1,20 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-VXZQNLPU.mjs";
+import {
+  __commonJS
+} from "./chunk-FB6YIQYR.mjs";
+
+// src/ps/isWin.js
+var require_isWin = __commonJS({
+  "src/ps/isWin.js"(exports, module) {
+    init_esm_shims();
+    var isWin = process.platform === "win32";
+    module.exports = isWin;
+  }
+});
+
+export {
+  require_isWin
+};

package/lib/chunk-OKYLF2MU.mjs

@@ -0,0 +1,53 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-VXZQNLPU.mjs";
+import {
+  __commonJS,
+  __require
+} from "./chunk-FB6YIQYR.mjs";
+
+// src/utils.js
+var require_utils = __commonJS({
+  "src/utils.js"(exports, module) {
+    init_esm_shims();
+    var { fs, path } = __require("sbg-utility");
+    var argv = __require("minimist")(process.argv.slice(2));
+    function getArgs() {
+      return argv;
+    }
+    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);
+        }
+      }
+    }
+    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);
+      });
+    }
+    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    module.exports = { del, delStream, getArgs, delay };
+  }
+});
+
+export {
+  require_utils
+};

package/lib/chunk-VXZQNLPU.mjs

@@ -0,0 +1,23 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __esm
+} from "./chunk-FB6YIQYR.mjs";
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname, __filename;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+    __filename = /* @__PURE__ */ getFilename();
+  }
+});
+
+export {
+  __dirname,
+  __filename,
+  init_esm_shims
+};

package/lib/del-gradle.cjs

@@ -0,0 +1,72 @@
+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/utils.js
+var require_utils = __commonJS({
+  "src/utils.js"(exports2, module2) {
+    init_cjs_shims();
+    var { fs, path: path2 } = require("sbg-utility");
+    var argv = require("minimist")(process.argv.slice(2));
+    function getArgs() {
+      return argv;
+    }
+    function del2(fullPath) {
+      if (fs.statSync(fullPath).isDirectory()) {
+        const subdir = fs.readdirSync(fullPath).map((dirPath) => path2.resolve(fullPath, dirPath));
+        for (let i = 0; i < subdir.length; i++) {
+          del2(subdir[i]);
+        }
+      } else {
+        try {
+          fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
+          console.log("deleted", fullPath);
+        } catch (_) {
+          console.log("failed delete", fullPath);
+        }
+      }
+    }
+    function delStream(globStream2) {
+      globStream2.stream().on("data", (result) => {
+        const fullPath = path2.resolve(process.cwd(), result);
+        if (fs.statSync(fullPath).isDirectory()) {
+          const subdir = fs.readdirSync(fullPath).map((dirPath) => path2.resolve(fullPath, dirPath));
+          for (let i = 0; i < subdir.length; i++) {
+            del2(subdir[i]);
+          }
+        }
+        del2(fullPath);
+      });
+    }
+    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    module2.exports = { del: del2, delStream, getArgs, delay };
+  }
+});
+
+// src/del-gradle.js
+init_cjs_shims();
+var glob = require("glob");
+var { path } = require("sbg-utility");
+var { del } = require_utils();
+var globStream = new glob.Glob(["**/build.gradle"], {
+  withFileTypes: false,
+  cwd: process.cwd(),
+  ignore: ["**/node_modules/**", "**/vendor/**"]
+});
+globStream.stream().on("data", (result) => {
+  const fullPath = path.resolve(process.cwd(), result);
+  const base = path.dirname(fullPath);
+  const buildFolder = path.join(base, "build");
+  console.log("delete build folder", buildFolder);
+  del(buildFolder);
+});

package/lib/del-gradle.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/del-gradle.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/del-gradle.js

@@ -0,0 +1,15 @@
+const glob = require("glob");
+const { path } = require("sbg-utility");
+const { del } = require("./utils");
+const globStream = new glob.Glob(["**/build.gradle"], {
+    withFileTypes: false,
+    cwd: process.cwd(),
+    ignore: ["**/node_modules/**", "**/vendor/**"]
+});
+globStream.stream().on("data", (result) => {
+    const fullPath = path.resolve(process.cwd(), result);
+    const base = path.dirname(fullPath);
+    const buildFolder = path.join(base, "build");
+    console.log("delete build folder", buildFolder);
+    del(buildFolder);
+});

package/lib/del-gradle.mjs

@@ -0,0 +1,28 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-OKYLF2MU.mjs";
+import {
+  init_esm_shims
+} from "./chunk-VXZQNLPU.mjs";
+import {
+  __require
+} from "./chunk-FB6YIQYR.mjs";
+
+// src/del-gradle.js
+init_esm_shims();
+var glob = __require("glob");
+var { path } = __require("sbg-utility");
+var { del } = require_utils();
+var globStream = new glob.Glob(["**/build.gradle"], {
+  withFileTypes: false,
+  cwd: process.cwd(),
+  ignore: ["**/node_modules/**", "**/vendor/**"]
+});
+globStream.stream().on("data", (result) => {
+  const fullPath = path.resolve(process.cwd(), result);
+  const base = path.dirname(fullPath);
+  const buildFolder = path.join(base, "build");
+  console.log("delete build folder", buildFolder);
+  del(buildFolder);
+});

package/lib/del-node-modules.cjs

@@ -0,0 +1,72 @@
+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/utils.js
+var require_utils = __commonJS({
+  "src/utils.js"(exports2, module2) {
+    init_cjs_shims();
+    var { fs, path } = require("sbg-utility");
+    var argv = require("minimist")(process.argv.slice(2));
+    function getArgs() {
+      return argv;
+    }
+    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);
+        }
+      }
+    }
+    function delStream2(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);
+      });
+    }
+    var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    module2.exports = { del, delStream: delStream2, getArgs, delay };
+  }
+});
+
+// src/del-node-modules.js
+init_cjs_shims();
+var glob = require("glob");
+var { delStream } = require_utils();
+var globalIgnore = [
+  // ignore .git .github folder
+  "**/.git*",
+  // ignore composer folder
+  "**/vendor/**"
+];
+console.log("cleaning node_modules in", process.cwd());
+var g3 = new glob.Glob("**/node_modules", {
+  withFileTypes: false,
+  cwd: process.cwd(),
+  ignore: globalIgnore
+});
+delStream(g3);

package/lib/del-node-modules.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/del-node-modules.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/del-node-modules.js

@@ -1,19 +1,15 @@
-const glob = require('glob');
-const { delStream } = require('./utils');
-// process.cwd = () => path.resolve(__dirname + '/../../../Repositories');
-
+const glob = require("glob");
+const { delStream } = require("./utils");
 const globalIgnore = [
-  // ignore .git .github folder
-  '**/.git*',
-  // ignore composer folder
-  '**/vendor/**'
+    // ignore .git .github folder
+    "**/.git*",
+    // ignore composer folder
+    "**/vendor/**"
 ];
-
-console.log('cleaning node_modules in', process.cwd());
-
-const g3 = new glob.Glob('**/node_modules', {
-  withFileTypes: false,
-  cwd: process.cwd(),
-  ignore: globalIgnore
+console.log("cleaning node_modules in", process.cwd());
+const g3 = new glob.Glob("**/node_modules", {
+    withFileTypes: false,
+    cwd: process.cwd(),
+    ignore: globalIgnore
 });
 delStream(g3);

package/lib/del-node-modules.mjs

@@ -0,0 +1,28 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils
+} from "./chunk-OKYLF2MU.mjs";
+import {
+  init_esm_shims
+} from "./chunk-VXZQNLPU.mjs";
+import {
+  __require
+} from "./chunk-FB6YIQYR.mjs";
+
+// src/del-node-modules.js
+init_esm_shims();
+var glob = __require("glob");
+var { delStream } = require_utils();
+var globalIgnore = [
+  // ignore .git .github folder
+  "**/.git*",
+  // ignore composer folder
+  "**/vendor/**"
+];
+console.log("cleaning node_modules in", process.cwd());
+var g3 = new glob.Glob("**/node_modules", {
+  withFileTypes: false,
+  cwd: process.cwd(),
+  ignore: globalIgnore
+});
+delStream(g3);