@codonsplice/wasm 0.1.0 → 0.1.1

package/astro/index.js

@@ -0,0 +1,6 @@
+// @codonsplice/astro — framework-agnostic helpers for Astro islands.
+//
+// Astro components are framework-agnostic, so this simply re-exports the core
+// helpers; use them inside a client:* island (or any of the framework wrappers
+// for reactive state).
+export { execute, stream, compile, check, initEngine, CodonSplice } from '../index.js'

package/astro/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@codonsplice/astro",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": { "@codonsplice/wasm": "0.1.0" },
+  "license": "MIT"
+}

package/index.js

@@ -0,0 +1,72 @@
+// @codonsplice/wasm — ergonomic entry point over the wasm-bindgen bindings.
+//
+// `codonsplice_wasm.js` (the wasm-pack output) exports the raw `CodonSplice`
+// class and a default `init()` that loads the .wasm. This module wraps them in
+// a singleton engine plus `execute`/`stream` helpers that accept File /
+// ArrayBuffer / Uint8Array values and normalize them to the Uint8Array map the
+// engine expects.
+
+import init, { CodonSplice } from './codonsplice_wasm.js'
+
+let _engine = null
+
+/** Initialize (once) and return the shared engine. */
+export async function initEngine() {
+  if (_engine) return _engine
+  await init()
+  _engine = new CodonSplice()
+  return _engine
+}
+
+export { CodonSplice }
+
+async function normalizeFiles(files) {
+  const fileMap = {}
+  for (const [name, fileOrBuffer] of Object.entries(files || {})) {
+    if (typeof File !== 'undefined' && fileOrBuffer instanceof File) {
+      fileMap[name] = new Uint8Array(await fileOrBuffer.arrayBuffer())
+    } else if (fileOrBuffer instanceof ArrayBuffer) {
+      fileMap[name] = new Uint8Array(fileOrBuffer)
+    } else {
+      fileMap[name] = fileOrBuffer // assume Uint8Array
+    }
+  }
+  return fileMap
+}
+
+/** Execute a query and return the result (array of records/rows, or { text }). */
+export async function execute({ query, files, vars }) {
+  const engine = await initEngine()
+  return engine.execute(query, await normalizeFiles(files), vars || {})
+}
+
+/** Execute pre-compiled .spq.bc bytecode (Uint8Array) against files + vars. */
+export async function executeBytecode({ bytecode, files, vars }) {
+  const engine = await initEngine()
+  return engine.execute_bytecode(bytecode, await normalizeFiles(files), vars || {})
+}
+
+/** Stream a query's records: onRecord per row, onDone at end, onError on fail. */
+export async function stream({ query, files, vars, onRecord, onDone, onError }) {
+  const engine = await initEngine()
+  return engine.stream(
+    query,
+    await normalizeFiles(files),
+    vars || {},
+    onRecord || (() => {}),
+    onDone || (() => {}),
+    onError || ((e) => console.error(e)),
+  )
+}
+
+/** Compile a query to disassembled bytecode (throws on error). */
+export async function compile(query) {
+  const engine = await initEngine()
+  return engine.compile(query)
+}
+
+/** Type-check a query: returns null on success, an error string on failure. */
+export async function check(query) {
+  const engine = await initEngine()
+  return engine.check(query)
+}

package/package.json

@@ -1,17 +1,36 @@
 {
   "name": "@codonsplice/wasm",
+  "version": "0.1.1",
+  "description": "CodonSplice — run SpliceQL genomic queries (BAM/VCF) in the browser via WASM",
   "type": "module",
-  "description": "CodonSplice WASM bindings — the @codonsplice/wasm npm package",
-  "version": "0.1.0",
-  "license": "MIT",
+  "main": "codonsplice_wasm.js",
+  "module": "codonsplice_wasm.js",
+  "types": "codonsplice_wasm.d.ts",
+  "exports": {
+    ".": {
+      "types": "./codonsplice_wasm.d.ts",
+      "import": "./codonsplice_wasm.js"
+    },
+    "./helpers": "./index.js",
+    "./react": "./react/index.js",
+    "./vue": "./vue/index.js",
+    "./svelte": "./svelte/index.js",
+    "./astro": "./astro/index.js"
+  },
   "files": [
     "codonsplice_wasm_bg.wasm",
     "codonsplice_wasm.js",
-    "codonsplice_wasm.d.ts"
+    "codonsplice_wasm.d.ts",
+    "index.js",
+    "react/",
+    "vue/",
+    "svelte/",
+    "astro/"
   ],
-  "main": "codonsplice_wasm.js",
-  "types": "codonsplice_wasm.d.ts",
   "sideEffects": [
-    "./snippets/*"
-  ]
-}
+    "./codonsplice_wasm.js"
+  ],
+  "keywords": ["genomics", "bioinformatics", "spliceql", "bam", "vcf", "wasm", "cnv", "variant-calling"],
+  "license": "MIT",
+  "repository": "github:Pogo-Bash/codonsplice"
+}

package/react/index.js

@@ -0,0 +1,26 @@
+// @codonsplice/react — a useSpliceQL() hook over @codonsplice/wasm.
+import { useState, useCallback } from 'react'
+import { execute as csExecute } from '../index.js'
+
+export function useSpliceQL() {
+  const [result, setResult] = useState(null)
+  const [error, setError] = useState(null)
+  const [loading, setLoading] = useState(false)
+
+  const execute = useCallback(async ({ query, files, vars }) => {
+    setLoading(true)
+    setError(null)
+    try {
+      const r = await csExecute({ query, files, vars })
+      setResult(r)
+      return r
+    } catch (e) {
+      setError(e)
+      throw e
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  return { execute, result, error, loading }
+}

package/react/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@codonsplice/react",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": { "@codonsplice/wasm": "0.1.0" },
+  "peerDependencies": { "react": "*" },
+  "license": "MIT"
+}

package/svelte/index.js

@@ -0,0 +1,26 @@
+// @codonsplice/svelte — a createSpliceQL() store factory over @codonsplice/wasm.
+import { writable } from 'svelte/store'
+import { execute as csExecute } from '../index.js'
+
+export function createSpliceQL() {
+  const result = writable(null)
+  const error = writable(null)
+  const loading = writable(false)
+
+  async function execute({ query, files, vars }) {
+    loading.set(true)
+    error.set(null)
+    try {
+      const r = await csExecute({ query, files, vars })
+      result.set(r)
+      return r
+    } catch (e) {
+      error.set(e)
+      throw e
+    } finally {
+      loading.set(false)
+    }
+  }
+
+  return { execute, result, error, loading }
+}

package/svelte/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@codonsplice/svelte",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": { "@codonsplice/wasm": "0.1.0" },
+  "peerDependencies": { "svelte": "*" },
+  "license": "MIT"
+}

package/vue/index.js

@@ -0,0 +1,25 @@
+// @codonsplice/vue — a useSpliceQL() composable over @codonsplice/wasm.
+import { ref } from 'vue'
+import { execute as csExecute } from '../index.js'
+
+export function useSpliceQL() {
+  const result = ref(null)
+  const error = ref(null)
+  const loading = ref(false)
+
+  async function execute({ query, files, vars }) {
+    loading.value = true
+    error.value = null
+    try {
+      result.value = await csExecute({ query, files, vars })
+      return result.value
+    } catch (e) {
+      error.value = e
+      throw e
+    } finally {
+      loading.value = false
+    }
+  }
+
+  return { execute, result, error, loading }
+}

package/vue/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@codonsplice/vue",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": { "@codonsplice/wasm": "0.1.0" },
+  "peerDependencies": { "vue": "*" },
+  "license": "MIT"
+}