@databio/gtars 0.5.3 → 0.6.0

package/gtars_js.d.ts

@@ -80,12 +80,218 @@ export class Tokenizer {
     readonly vocabSize: number;
 }
 
+/**
+ * Canonicalize a JSON string according to RFC-8785.
+ *
+ * This is useful for computing digests of JSON objects in a deterministic way.
+ *
+ * # Arguments
+ * * `json_str` - A JSON string
+ *
+ * # Returns
+ * The canonicalized JSON string
+ */
+export function canonicalizeJsonString(json_str: string): string;
+
+/**
+ * Compute the MD5 digest of a string.
+ *
+ * Low-level function that does NOT uppercase the input.
+ *
+ * # Arguments
+ * * `input` - The input string
+ *
+ * # Returns
+ * The MD5 digest as a hex string
+ */
+export function computeMd5(input: string): string;
+
+/**
+ * Compute the sha512t24u digest of a string.
+ *
+ * This is a low-level function that computes the GA4GH standard digest
+ * of arbitrary input. Unlike `sequence_digest`, this does NOT uppercase
+ * the input.
+ *
+ * # Arguments
+ * * `input` - The input string
+ *
+ * # Returns
+ * The sha512t24u digest string (base64url encoded)
+ */
+export function computeSha512t24u(input: string): string;
+
+/**
+ * Compute a seqcol (sequence collection) digest from FASTA content.
+ *
+ * This function takes FASTA file content as bytes and returns a JSON object
+ * containing the sequence collection digest and metadata. Automatically handles
+ * gzip-compressed FASTA files.
+ *
+ * # Arguments
+ * * `fasta_content` - The FASTA file content as a Uint8Array (supports gzip)
+ *
+ * # Returns
+ * A JavaScript object containing:
+ * - `digest`: The top-level seqcol digest
+ * - `names_digest`: Level 1 digest of sequence names
+ * - `sequences_digest`: Level 1 digest of sequence digests
+ * - `lengths_digest`: Level 1 digest of sequence lengths
+ * - `n_sequences`: Number of sequences
+ * - `sequences`: Array of sequence metadata objects
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const fastaContent = new TextEncoder().encode(">chr1\nACGT\n");
+ * const result = digestSeqcol(fastaContent);
+ * console.log(result.digest);  // Top-level seqcol digest
+ * ```
+ */
+export function digestSeqcol(fasta_content: Uint8Array): any;
+
+/**
+ * Finalize the hasher and return the results.
+ *
+ * This consumes the hasher and frees its resources.
+ * After calling this, the handle is no longer valid.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ *
+ * # Returns
+ * A JavaScript object with the sequence collection result,
+ * or an error if the handle is invalid.
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const handle = fastaHasherNew();
+ * fastaHasherUpdate(handle, fastaData);
+ * const result = fastaHasherFinish(handle);
+ * console.log(result.digest);
+ * ```
+ */
+export function fastaHasherFinish(handle: number): any;
+
+/**
+ * Free a hasher without getting results.
+ *
+ * Use this if you need to cancel processing early.
+ * After calling this, the handle is no longer valid.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ *
+ * # Returns
+ * `true` if the handle was valid and freed, `false` otherwise.
+ */
+export function fastaHasherFree(handle: number): boolean;
+
+/**
+ * Create a new streaming FASTA hasher.
+ *
+ * Returns a handle (u32) that must be used in subsequent calls.
+ * The handle must be freed with `fastaHasherFinish()` or `fastaHasherFree()`.
+ *
+ * # Returns
+ * A handle ID (always > 0).
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const handle = fastaHasherNew();
+ * // ... use handle with fastaHasherUpdate ...
+ * const result = fastaHasherFinish(handle);
+ * ```
+ */
+export function fastaHasherNew(): number;
+
+/**
+ * Get the current progress of a streaming hasher.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ *
+ * # Returns
+ * A JavaScript object with progress information, or null if handle is invalid.
+ * The object contains:
+ * - `completed_sequences`: Number of fully processed sequences
+ * - `current_sequence_name`: Name of sequence being processed (if any)
+ * - `current_sequence_length`: Length of sequence being processed
+ */
+export function fastaHasherProgress(handle: number): any;
+
+/**
+ * Process a chunk of FASTA data.
+ *
+ * This can be called multiple times with successive chunks.
+ * Handles both plain text and gzip-compressed FASTA.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ * * `chunk` - A chunk of FASTA data as Uint8Array
+ *
+ * # Returns
+ * Ok on success, or an error with details about what went wrong.
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const handle = fastaHasherNew();
+ * fastaHasherUpdate(handle, new TextEncoder().encode(">chr1\nACGT"));
+ * fastaHasherUpdate(handle, new TextEncoder().encode("\n>chr2\nTGCA\n"));
+ * ```
+ */
+export function fastaHasherUpdate(handle: number, chunk: Uint8Array): void;
+
 export function greet(name: string): void;
 
+/**
+ * Compute a sequence digest (sha512t24u) from raw sequence data.
+ *
+ * This is the GA4GH standard digest for sequences. The sequence is uppercased
+ * before computing the digest.
+ *
+ * # Arguments
+ * * `sequence` - The sequence string (A, C, G, T, etc.)
+ *
+ * # Returns
+ * The sha512t24u digest string (base64url encoded)
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const digest = sequenceDigest("ACGT");
+ * console.log(digest);  // "aKF498dAxcJAqme6QYQ7EZ07-fiw8Kw2"
+ * ```
+ */
+export function sequenceDigest(sequence: string): string;
+
+/**
+ * Compute an MD5 digest from raw sequence data.
+ *
+ * The sequence is uppercased before computing the digest.
+ *
+ * # Arguments
+ * * `sequence` - The sequence string
+ *
+ * # Returns
+ * The MD5 digest as a hex string
+ */
+export function sequenceMd5(sequence: string): string;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly greet: (a: number, b: number) => void;
+    readonly canonicalizeJsonString: (a: number, b: number) => [number, number, number, number];
+    readonly computeMd5: (a: number, b: number) => [number, number];
+    readonly computeSha512t24u: (a: number, b: number) => [number, number];
+    readonly digestSeqcol: (a: number, b: number) => [number, number, number];
+    readonly fastaHasherFinish: (a: number) => [number, number, number];
+    readonly fastaHasherFree: (a: number) => number;
+    readonly fastaHasherNew: () => number;
+    readonly fastaHasherProgress: (a: number) => [number, number, number];
+    readonly fastaHasherUpdate: (a: number, b: number, c: number) => [number, number];
+    readonly sequenceDigest: (a: number, b: number) => [number, number];
+    readonly sequenceMd5: (a: number, b: number) => [number, number];
     readonly __wbg_bedclassificationoutput_free: (a: number, b: number) => void;
     readonly __wbg_chromosomestatistics_free: (a: number, b: number) => void;
     readonly __wbg_regiondistribution_free: (a: number, b: number) => void;
@@ -138,7 +344,6 @@ export interface InitOutput {
     readonly overlapper_find: (a: number, b: any) => [number, number, number];
     readonly overlapper_get_backend: (a: number) => [number, number];
     readonly overlapper_new: (a: any, b: number, c: number) => [number, number, number];
-    readonly greet: (a: number, b: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/gtars_js.js

@@ -567,6 +567,262 @@ export class Tokenizer {
 }
 if (Symbol.dispose) Tokenizer.prototype[Symbol.dispose] = Tokenizer.prototype.free;
 
+/**
+ * Canonicalize a JSON string according to RFC-8785.
+ *
+ * This is useful for computing digests of JSON objects in a deterministic way.
+ *
+ * # Arguments
+ * * `json_str` - A JSON string
+ *
+ * # Returns
+ * The canonicalized JSON string
+ * @param {string} json_str
+ * @returns {string}
+ */
+export function canonicalizeJsonString(json_str) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.canonicalizeJsonString(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Compute the MD5 digest of a string.
+ *
+ * Low-level function that does NOT uppercase the input.
+ *
+ * # Arguments
+ * * `input` - The input string
+ *
+ * # Returns
+ * The MD5 digest as a hex string
+ * @param {string} input
+ * @returns {string}
+ */
+export function computeMd5(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.computeMd5(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Compute the sha512t24u digest of a string.
+ *
+ * This is a low-level function that computes the GA4GH standard digest
+ * of arbitrary input. Unlike `sequence_digest`, this does NOT uppercase
+ * the input.
+ *
+ * # Arguments
+ * * `input` - The input string
+ *
+ * # Returns
+ * The sha512t24u digest string (base64url encoded)
+ * @param {string} input
+ * @returns {string}
+ */
+export function computeSha512t24u(input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.computeSha512t24u(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Compute a seqcol (sequence collection) digest from FASTA content.
+ *
+ * This function takes FASTA file content as bytes and returns a JSON object
+ * containing the sequence collection digest and metadata. Automatically handles
+ * gzip-compressed FASTA files.
+ *
+ * # Arguments
+ * * `fasta_content` - The FASTA file content as a Uint8Array (supports gzip)
+ *
+ * # Returns
+ * A JavaScript object containing:
+ * - `digest`: The top-level seqcol digest
+ * - `names_digest`: Level 1 digest of sequence names
+ * - `sequences_digest`: Level 1 digest of sequence digests
+ * - `lengths_digest`: Level 1 digest of sequence lengths
+ * - `n_sequences`: Number of sequences
+ * - `sequences`: Array of sequence metadata objects
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const fastaContent = new TextEncoder().encode(">chr1\nACGT\n");
+ * const result = digestSeqcol(fastaContent);
+ * console.log(result.digest);  // Top-level seqcol digest
+ * ```
+ * @param {Uint8Array} fasta_content
+ * @returns {any}
+ */
+export function digestSeqcol(fasta_content) {
+    const ptr0 = passArray8ToWasm0(fasta_content, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.digestSeqcol(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Finalize the hasher and return the results.
+ *
+ * This consumes the hasher and frees its resources.
+ * After calling this, the handle is no longer valid.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ *
+ * # Returns
+ * A JavaScript object with the sequence collection result,
+ * or an error if the handle is invalid.
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const handle = fastaHasherNew();
+ * fastaHasherUpdate(handle, fastaData);
+ * const result = fastaHasherFinish(handle);
+ * console.log(result.digest);
+ * ```
+ * @param {number} handle
+ * @returns {any}
+ */
+export function fastaHasherFinish(handle) {
+    const ret = wasm.fastaHasherFinish(handle);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Free a hasher without getting results.
+ *
+ * Use this if you need to cancel processing early.
+ * After calling this, the handle is no longer valid.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ *
+ * # Returns
+ * `true` if the handle was valid and freed, `false` otherwise.
+ * @param {number} handle
+ * @returns {boolean}
+ */
+export function fastaHasherFree(handle) {
+    const ret = wasm.fastaHasherFree(handle);
+    return ret !== 0;
+}
+
+/**
+ * Create a new streaming FASTA hasher.
+ *
+ * Returns a handle (u32) that must be used in subsequent calls.
+ * The handle must be freed with `fastaHasherFinish()` or `fastaHasherFree()`.
+ *
+ * # Returns
+ * A handle ID (always > 0).
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const handle = fastaHasherNew();
+ * // ... use handle with fastaHasherUpdate ...
+ * const result = fastaHasherFinish(handle);
+ * ```
+ * @returns {number}
+ */
+export function fastaHasherNew() {
+    const ret = wasm.fastaHasherNew();
+    return ret >>> 0;
+}
+
+/**
+ * Get the current progress of a streaming hasher.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ *
+ * # Returns
+ * A JavaScript object with progress information, or null if handle is invalid.
+ * The object contains:
+ * - `completed_sequences`: Number of fully processed sequences
+ * - `current_sequence_name`: Name of sequence being processed (if any)
+ * - `current_sequence_length`: Length of sequence being processed
+ * @param {number} handle
+ * @returns {any}
+ */
+export function fastaHasherProgress(handle) {
+    const ret = wasm.fastaHasherProgress(handle);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Process a chunk of FASTA data.
+ *
+ * This can be called multiple times with successive chunks.
+ * Handles both plain text and gzip-compressed FASTA.
+ *
+ * # Arguments
+ * * `handle` - The hasher handle from `fastaHasherNew()`
+ * * `chunk` - A chunk of FASTA data as Uint8Array
+ *
+ * # Returns
+ * Ok on success, or an error with details about what went wrong.
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const handle = fastaHasherNew();
+ * fastaHasherUpdate(handle, new TextEncoder().encode(">chr1\nACGT"));
+ * fastaHasherUpdate(handle, new TextEncoder().encode("\n>chr2\nTGCA\n"));
+ * ```
+ * @param {number} handle
+ * @param {Uint8Array} chunk
+ */
+export function fastaHasherUpdate(handle, chunk) {
+    const ptr0 = passArray8ToWasm0(chunk, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fastaHasherUpdate(handle, ptr0, len0);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
 /**
  * @param {string} name
  */
@@ -576,6 +832,69 @@ export function greet(name) {
     wasm.greet(ptr0, len0);
 }
 
+/**
+ * Compute a sequence digest (sha512t24u) from raw sequence data.
+ *
+ * This is the GA4GH standard digest for sequences. The sequence is uppercased
+ * before computing the digest.
+ *
+ * # Arguments
+ * * `sequence` - The sequence string (A, C, G, T, etc.)
+ *
+ * # Returns
+ * The sha512t24u digest string (base64url encoded)
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const digest = sequenceDigest("ACGT");
+ * console.log(digest);  // "aKF498dAxcJAqme6QYQ7EZ07-fiw8Kw2"
+ * ```
+ * @param {string} sequence
+ * @returns {string}
+ */
+export function sequenceDigest(sequence) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(sequence, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sequenceDigest(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Compute an MD5 digest from raw sequence data.
+ *
+ * The sequence is uppercased before computing the digest.
+ *
+ * # Arguments
+ * * `sequence` - The sequence string
+ *
+ * # Returns
+ * The MD5 digest as a hex string
+ * @param {string} sequence
+ * @returns {string}
+ */
+export function sequenceMd5(sequence) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(sequence, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sequenceMd5(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -636,7 +955,7 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_alert_a95ce7722f153d07: function(arg0, arg1) {
+        __wbg_alert_b04a0b1c35e31e39: function(arg0, arg1) {
             alert(getStringFromWasm0(arg0, arg1));
         },
         __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
@@ -746,6 +1065,11 @@ function __wbg_get_imports() {
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);
@@ -891,6 +1215,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

@@ -4,7 +4,7 @@
   "collaborators": [
     "Nathan LeRoy <NLeRoy917@gmail.com>"
   ],
-  "version": "0.5.3",
+  "version": "0.6.0",
   "files": [
     "gtars_js_bg.wasm",
     "gtars_js.js",