@gmod/bbi 1.0.28 → 1.0.32

package/esm/range.js

@@ -0,0 +1,126 @@
+"use strict";
+/* eslint prefer-rest-params:0, no-nested-ternary:0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Adapted from a combination of Range and _Compound in the
+ * Dalliance Genome Explorer, (c) Thomas Down 2006-2010.
+ */
+class Range {
+    constructor(arg1, arg2) {
+        this.ranges =
+            arguments.length === 2
+                ? [{ min: arg1, max: arg2 }]
+                : 0 in arg1
+                    ? Object.assign({}, arg1)
+                    : [arg1];
+    }
+    min() {
+        return this.ranges[0].min;
+    }
+    max() {
+        return this.ranges[this.ranges.length - 1].max;
+    }
+    contains(pos) {
+        for (let s = 0; s < this.ranges.length; s += 1) {
+            const r = this.ranges[s];
+            if (r.min <= pos && r.max >= pos) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isContiguous() {
+        return this.ranges.length > 1;
+    }
+    getRanges() {
+        return this.ranges.map((r) => new Range(r.min, r.max));
+    }
+    toString() {
+        return this.ranges.map((r) => `[${r.min}-${r.max}]`).join(',');
+    }
+    union(s1) {
+        const ranges = this.getRanges().concat(s1.getRanges()).sort(this.rangeOrder);
+        const oranges = [];
+        let current = ranges[0];
+        for (let i = 1; i < ranges.length; i += 1) {
+            const nxt = ranges[i];
+            if (nxt.min() > current.max() + 1) {
+                oranges.push(current);
+                current = nxt;
+            }
+            else if (nxt.max() > current.max()) {
+                current = new Range(current.min(), nxt.max());
+            }
+        }
+        oranges.push(current);
+        if (oranges.length === 1) {
+            return oranges[0];
+        }
+        return new Range(oranges);
+    }
+    intersection(arg) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let s0 = this;
+        let s1 = arg;
+        const r0 = this.ranges();
+        const r1 = s1.ranges();
+        const l0 = r0.length;
+        const l1 = r1.length;
+        let i0 = 0;
+        let i1 = 0;
+        const or = [];
+        while (i0 < l0 && i1 < l1) {
+            s0 = r0[i0];
+            s1 = r1[i1];
+            const lapMin = Math.max(s0.min(), s1.min());
+            const lapMax = Math.min(s0.max(), s1.max());
+            if (lapMax >= lapMin) {
+                or.push(new Range(lapMin, lapMax));
+            }
+            if (s0.max() > s1.max()) {
+                i1 += 1;
+            }
+            else {
+                i0 += 1;
+            }
+        }
+        if (or.length === 0) {
+            throw new Error('found range of length 0');
+        }
+        if (or.length === 1) {
+            return or[0];
+        }
+        return new Range(or);
+    }
+    coverage() {
+        let tot = 0;
+        const rl = this.ranges();
+        for (let ri = 0; ri < rl.length; ri += 1) {
+            const r = rl[ri];
+            tot += r.max() - r.min() + 1;
+        }
+        return tot;
+    }
+    rangeOrder(tmpa, tmpb) {
+        let a = tmpa;
+        let b = tmpb;
+        if (arguments.length < 2) {
+            b = a;
+            a = this;
+        }
+        if (a.min() < b.min()) {
+            return -1;
+        }
+        if (a.min() > b.min()) {
+            return 1;
+        }
+        if (a.max() < b.max()) {
+            return -1;
+        }
+        if (b.max() > a.max()) {
+            return 1;
+        }
+        return 0;
+    }
+}
+exports.default = Range;

package/esm/unzip-pako.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function unzip(input: Buffer): Buffer;

package/esm/unzip-pako.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = void 0;
+const pako_1 = require("pako");
+function unzip(input) {
+    return Buffer.from((0, pako_1.inflate)(input));
+}
+exports.unzip = unzip;

package/esm/unzip.d.ts

@@ -0,0 +1,2 @@
+import { inflateSync } from 'zlib';
+export { inflateSync as unzip };

package/esm/unzip.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = void 0;
+const zlib_1 = require("zlib");
+Object.defineProperty(exports, "unzip", { enumerable: true, get: function () { return zlib_1.inflateSync; } });

package/esm/util.d.ts

@@ -0,0 +1,24 @@
+export declare class AbortError extends Error {
+    code: string;
+    constructor(message: string);
+}
+export declare function groupBlocks(blocks: any[]): any[];
+/**
+ * Properly check if the given AbortSignal is aborted.
+ * Per the standard, if the signal reads as aborted,
+ * this function throws either a DOMException AbortError, or a regular error
+ * with a `code` attribute set to `ERR_ABORTED`.
+ *
+ * For convenience, passing `undefined` is a no-op
+ *
+ * @param {AbortSignal} [signal] an AbortSignal, or anything with an `aborted` attribute
+ * @returns nothing
+ */
+export declare function checkAbortSignal(signal?: AbortSignal): void;
+/**
+ * Skips to the next tick, then runs `checkAbortSignal`.
+ * Await this to inside an otherwise synchronous loop to
+ * provide a place to break when an abort signal is received.
+ * @param {AbortSignal} signal
+ */
+export declare function abortBreakPoint(signal?: AbortSignal): Promise<void>;

package/esm/util.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortBreakPoint = exports.checkAbortSignal = exports.groupBlocks = exports.AbortError = void 0;
+/* eslint no-bitwise: ["error", { "allow": ["|"] }] */
+class AbortError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'ERR_ABORTED';
+    }
+}
+exports.AbortError = AbortError;
+// sort blocks by file offset and
+// group blocks that are within 2KB of eachother
+function groupBlocks(blocks) {
+    blocks.sort((b0, b1) => (b0.offset | 0) - (b1.offset | 0));
+    const blockGroups = [];
+    let lastBlock;
+    let lastBlockEnd;
+    for (let i = 0; i < blocks.length; i += 1) {
+        if (lastBlock && blocks[i].offset - lastBlockEnd <= 2000) {
+            lastBlock.length += blocks[i].length - lastBlockEnd + blocks[i].offset;
+            lastBlock.blocks.push(blocks[i]);
+        }
+        else {
+            blockGroups.push((lastBlock = {
+                blocks: [blocks[i]],
+                length: blocks[i].length,
+                offset: blocks[i].offset,
+            }));
+        }
+        lastBlockEnd = lastBlock.offset + lastBlock.length;
+    }
+    return blockGroups;
+}
+exports.groupBlocks = groupBlocks;
+/**
+ * Properly check if the given AbortSignal is aborted.
+ * Per the standard, if the signal reads as aborted,
+ * this function throws either a DOMException AbortError, or a regular error
+ * with a `code` attribute set to `ERR_ABORTED`.
+ *
+ * For convenience, passing `undefined` is a no-op
+ *
+ * @param {AbortSignal} [signal] an AbortSignal, or anything with an `aborted` attribute
+ * @returns nothing
+ */
+function checkAbortSignal(signal) {
+    if (!signal) {
+        return;
+    }
+    if (signal.aborted) {
+        // console.log('bam aborted!')
+        if (typeof DOMException !== 'undefined') {
+            throw new DOMException('aborted', 'AbortError');
+        }
+        else {
+            const e = new AbortError('aborted');
+            e.code = 'ERR_ABORTED';
+            throw e;
+        }
+    }
+}
+exports.checkAbortSignal = checkAbortSignal;
+/**
+ * Skips to the next tick, then runs `checkAbortSignal`.
+ * Await this to inside an otherwise synchronous loop to
+ * provide a place to break when an abort signal is received.
+ * @param {AbortSignal} signal
+ */
+async function abortBreakPoint(signal) {
+    await Promise.resolve();
+    checkAbortSignal(signal);
+}
+exports.abortBreakPoint = abortBreakPoint;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@gmod/bbi",
-  "version": "1.0.28",
+  "version": "1.0.32",
   "description": "Parser for BigWig/BigBed files",
   "license": "MIT",
   "repository": "GMOD/bbi-js",
   "main": "dist/index.js",
+  "module": "esm/index.js",
   "author": {
     "name": "Colin Diesh",
     "email": "colin.diesh@gmail.com",
@@ -14,20 +15,21 @@
     "node": ">=6"
   },
   "files": [
-    "dist"
+    "dist",
+    "esm"
   ],
   "scripts": {
     "test": "jest",
     "coverage": "npm test -- --coverage",
     "lint": "eslint --report-unused-disable-directives --max-warnings 0 --ext .js,.ts src",
-    "clean": "rimraf dist",
+    "clean": "rimraf dist esm",
     "prebuild": "npm run clean",
-    "build:types": "tsc --emitDeclarationOnly",
-    "build:js": "babel src --out-dir dist --extensions \".ts,.tsx\" --source-maps inline",
-    "build": "npm run build:types && npm run build:js",
+    "build:esm": "tsc --target es2018 --outDir esm",
+    "build:es5": "tsc --target es5 --outDir dist",
+    "build": "npm run build:esm && npm run build:es5",
     "preversion": "npm run lint && npm test && npm run build",
     "version": "standard-changelog && git add CHANGELOG.md",
-    "postpublish": "git push origin master --follow-tags"
+    "postversion": "git push origin master --follow-tags"
   },
   "keywords": [
     "bionode",
@@ -38,44 +40,40 @@
     "genomics"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.4.4",
-    "@gmod/binary-parser": "^1.3.5",
-    "abortable-promise-cache": "^1.0.1",
+    "@gmod/binary-parser": "^1.4.0",
+    "abortable-promise-cache": "^1.4.1",
     "buffer-crc32": "^0.2.13",
     "es6-promisify": "^6.0.1",
     "generic-filehandle": "^2.0.0",
+    "pako": "^1.0.0",
     "quick-lru": "^4.0.0",
     "rxjs": "^6.5.2"
   },
   "devDependencies": {
-    "@babel/cli": "^7.4.4",
-    "@babel/core": "^7.4.4",
-    "@babel/plugin-proposal-class-properties": "^7.4.4",
-    "@babel/plugin-transform-runtime": "^7.4.4",
-    "@babel/preset-env": "^7.4.4",
-    "@babel/preset-typescript": "^7.3.3",
     "@gmod/bed": "^2.0.0",
-    "@types/jest": "^24.0.13",
+    "@types/jest": "^27.0.3",
     "@types/long": "^4.0.0",
     "@types/node": "^12.0.2",
-    "@typescript-eslint/eslint-plugin": "^2.0.0",
-    "@typescript-eslint/parser": "^2.0.0",
-    "babel-eslint": "^10.0.1",
-    "babel-preset-typescript": "^7.0.0-alpha.19",
+    "@types/pako": "^1.0.3",
+    "@typescript-eslint/eslint-plugin": "^5.10.0",
+    "@typescript-eslint/parser": "^5.10.0",
     "cross-fetch": "^3.0.2",
-    "eslint": "^5.16.0",
-    "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-config-prettier": "^4.2.0",
-    "eslint-plugin-import": "^2.17.2",
-    "eslint-plugin-jest": "^22.5.1",
-    "eslint-plugin-prettier": "^3.1.0",
-    "jest": "^24.8.0",
-    "prettier": "^1.17.1",
-    "rimraf": "^2.6.3",
+    "eslint": "^8.7.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^27.4.3",
+    "prettier": "^2.5.1",
+    "rimraf": "^3.0.2",
     "standard-changelog": "^2.0.11",
-    "typescript": "^3.4.5"
+    "ts-jest": "^27.0.7",
+    "typescript": "^4.5.2"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "browser": {
+    "./esm/unzip.js": "./esm/unzip-pako.js",
+    "./dist/unzip.js": "./dist/unzip-pako.js"
   }
 }

package/dist/declares.d.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=