@gmod/cram 1.6.3 → 1.7.0

package/dist/cramFile/encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.js","sourceRoot":"","sources":["../../src/cramFile/encoding.ts"],"names":[],"mappings":""}

package/dist/cramFile/file.d.ts

@@ -1,63 +1,113 @@
+/// <reference types="node" />
+import QuickLRU from 'quick-lru';
+import { BlockHeader, CompressionMethod } from './sectionParsers';
+import CramContainer from './container';
+import { Parser } from '@gmod/binary-parser';
+import CramRecord from './record';
+import { Filehandle } from './filehandle';
+export declare type CramFileSource = {
+    filehandle?: Filehandle;
+    url?: string;
+    path?: string;
+};
+export declare type SeqFetch = (seqId: number, start: number, end: number) => Promise<string>;
+export declare type CramFileArgs = CramFileSource & {
+    checkSequenceMD5: boolean;
+    cacheSize?: number;
+    seqFetch: SeqFetch;
+};
+export declare type CramFileBlock = BlockHeader & {
+    _endPosition: number;
+    contentPosition: number;
+    _size: number;
+    content: Buffer;
+    crc32?: number;
+};
 export default class CramFile {
-    /**
-     * @param {object} args
-     * @param {object} [args.filehandle] - a filehandle that implements the stat() and
-     * read() methods of the Node filehandle API https://nodejs.org/api/fs.html#fs_class_filehandle
-     * @param {object} [args.path] - path to the cram file
-     * @param {object} [args.url] - url for the cram file.  also supports file:// urls for local files
-     * @param {function} [args.seqFetch] - a function with signature
-     * `(seqId, startCoordinate, endCoordinate)` that returns a promise for a string of sequence bases
-     * @param {number} [args.cacheSize] optional maximum number of CRAM records to cache.  default 20,000
-     * @param {boolean} [args.checkSequenceMD5] - default true. if false, disables verifying the MD5
-     * checksum of the reference sequence underlying a slice. In some applications, this check can cause an inconvenient amount (many megabases) of sequences to be fetched.
-     */
-    constructor(args: {
-        filehandle?: object | undefined;
-        path?: object | undefined;
-        url?: object | undefined;
-        seqFetch?: Function | undefined;
-        cacheSize?: number | undefined;
-        checkSequenceMD5?: boolean | undefined;
-    });
-    file: any;
+    private file;
     validateChecksums: boolean;
-    fetchReferenceSequenceCallback: Function | undefined;
+    fetchReferenceSequenceCallback: SeqFetch;
     options: {
         checkSequenceMD5: boolean;
         cacheSize: number;
     };
-    featureCache: any;
-    toString(): any;
-    read(buffer: any, offset: any, length: any, position: any): any;
-    stat(): any;
+    featureCache: QuickLRU<string, Promise<CramRecord[]>>;
+    private header;
+    constructor(args: CramFileArgs);
+    read(buffer: Buffer, offset: number, length: number, position: number): Promise<{
+        bytesRead: number;
+        buffer: Buffer;
+    }>;
+    stat(): Promise<import("generic-filehandle").Stats>;
     getDefinition(): Promise<any>;
-    getSamHeader(): Promise<any[]>;
-    header: any;
-    getHeaderText(): Promise<any>;
+    getSamHeader(): Promise<import("../sam").HeaderDataItem[]>;
+    getHeaderText(): Promise<string | undefined>;
     getSectionParsers(): Promise<{
         cramFileDefinition: {
-            parser: any;
+            parser: Parser<{
+                magic: string;
+                majorVersion: number;
+                minorVersion: number;
+                fileId: string;
+            }>;
+            maxLength: number;
+        };
+        cramContainerHeader1: {
+            parser: Parser<{
+                length: number;
+                refSeqId: number;
+                refSeqStart: number;
+                alignmentSpan: number;
+                numRecords: number;
+                recordCounter: number;
+                numBases: number;
+                numBlocks: number;
+                numLandmarks: number;
+            }>;
             maxLength: number;
         };
+        cramContainerHeader2: {
+            parser: Parser<{
+                numLandmarks: number;
+                landmarks: number[];
+                crc32: number;
+            }>;
+            maxLength: (x: number) => number;
+        };
         cramBlockHeader: {
-            parser: any;
+            parser: Parser<BlockHeader>;
             maxLength: number;
         };
         cramBlockCrc32: {
-            parser: any;
+            parser: Parser<{
+                crc32: number;
+            }>;
             maxLength: number;
         };
+        cramCompressionHeader: {
+            parser: Parser<import("./sectionParsers").CramCompressionHeader>;
+        };
+        cramMappedSliceHeader: {
+            parser: Parser<import("./sectionParsers").MappedSliceHeader>;
+            maxLength: (numContentIds: number) => number;
+        };
+        cramUnmappedSliceHeader: {
+            parser: Parser<import("./sectionParsers").UnmappedSliceHeader>;
+            maxLength: (numContentIds: number) => number;
+        };
     }>;
-    getContainerById(containerNumber: any): Promise<CramContainer | undefined>;
-    checkCrc32(position: any, length: any, recordedCrc32: any, description: any): Promise<void>;
+    getContainerById(containerNumber: number): Promise<CramContainer | undefined>;
+    checkCrc32(position: number, length: number, recordedCrc32: number, description: string): Promise<void>;
     /**
      * @returns {Promise[number]} the number of containers in the file
      */
-    containerCount(): any;
-    getContainerAtPosition(position: any): CramContainer;
-    readBlockHeader(position: any): Promise<any>;
-    _parseSection(section: any, position: any, size: any, preReadBuffer: any): Promise<any>;
-    _uncompress(compressionMethod: any, inputBuffer: any, outputBuffer: any): void;
-    readBlock(position: any): Promise<any>;
+    containerCount(): Promise<number | undefined>;
+    getContainerAtPosition(position: number): CramContainer;
+    readBlockHeader(position: number): Promise<import("./util").ParsedItem<BlockHeader> | undefined>;
+    _parseSection<T>(section: {
+        parser: Parser<T>;
+        maxLength: number;
+    }, position: number, size?: number, preReadBuffer?: undefined): Promise<import("./util").ParsedItem<T> | undefined>;
+    _uncompress(compressionMethod: CompressionMethod, inputBuffer: Buffer, outputBuffer: Buffer): void;
+    readBlock(position: number): Promise<CramFileBlock | undefined>;
 }
-import CramContainer from "./container";