bids-validator-deno 2.0.11__tar.gz → 2.1.1__tar.gz

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bids-validator-deno
-Version: 2.0.11
+Version: 2.1.1
 Summary: Typescript implementation of the BIDS validator
 Keywords: BIDS,BIDS validator
 Author: bids-standard developers

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@bids/validator",
-  "version": "2.0.11",
+  "version": "2.1.1",
   "exports": {
     ".": "./src/bids-validator.ts",
     "./main": "./src/main.ts",
@@ -27,22 +27,22 @@
     ]
   },
   "imports": {
-    "@ajv": "npm:ajv@8.17.1",
-    "@bids/schema": "jsr:@bids/schema@~1.0.14",
+    "@ajv": "npm:ajv@^8.17.1",
+    "@bids/schema": "jsr:@bids/schema@~1.1.0",
     "@cliffy/command": "jsr:@effigies/cliffy-command@1.0.0-dev.8",
     "@cliffy/table": "jsr:@effigies/cliffy-table@1.0.0-dev.5",
-    "@hed/validator": "npm:hed-validator@4.0.1",
-    "@ignore": "npm:ignore@7.0.3",
-    "@libs/xml": "jsr:@libs/xml@6.0.4",
-    "@mango/nifti": "npm:@bids/nifti-reader-js@0.6.9",
-    "@std/assert": "jsr:@std/assert@1.0.12",
-    "@std/fmt": "jsr:@std/fmt@1.0.6",
-    "@std/fs": "jsr:@std/fs@1.0.15",
-    "@std/io": "jsr:@std/io@0.225.2",
-    "@std/log": "jsr:@std/log@0.224.14",
-    "@std/path": "jsr:@std/path@1.0.8",
-    "@std/streams": "jsr:@std/streams@1.0.9",
-    "@std/yaml": "jsr:@std/yaml@^1.0.5"
+    "@hed/validator": "npm:hed-validator@~4.0.1",
+    "@ignore": "npm:ignore@^7.0.5",
+    "@libs/xml": "jsr:@libs/xml@^6.0.8",
+    "@mango/nifti": "npm:@bids/nifti-reader-js@^0.6.9",
+    "@std/assert": "jsr:@std/assert@^1.0.14",
+    "@std/fmt": "jsr:@std/fmt@^1.0.8",
+    "@std/fs": "jsr:@std/fs@^1.0.19",
+    "@std/io": "jsr:@std/io@^0.225.2",
+    "@std/log": "jsr:@std/log@^0.224.14",
+    "@std/path": "jsr:@std/path@^1.1.2",
+    "@std/streams": "jsr:@std/streams@^1.0.12",
+    "@std/yaml": "jsr:@std/yaml@^1.0.9"
   },
   "tasks": {
     "test": "deno test -A src/"
@@ -54,6 +54,9 @@
     "proseWrap": "preserve",
     "include": [
       "src/"
+    ],
+    "exclude": [
+      "src/tests/bom-utf8.json"
     ]
   }
 }

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/pyproject.toml

@@ -18,7 +18,7 @@ keywords = [
     "BIDS validator",
 ]
 dynamic = []
-version = "2.0.11"
+version = "2.1.1"
 
 [project.license]
 text = "MIT"

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/bids-validator.ts

@@ -6,3 +6,4 @@ const errors = result.issues.get({ severity: 'error' })
 if (errors.length) {
   Deno.exit(16)
 }
+Deno.exit(0)

bids_validator_deno-2.1.1/src/files/access.test.ts

@@ -0,0 +1,40 @@
+import { assert, assertArrayIncludes, assertObjectMatch } from '@std/assert'
+import { basename, dirname } from '@std/path'
+import { BIDSFileDeno } from './deno.ts'
+
+export function testAsyncFileAccess(
+  name: string,
+  fn: (file: BIDSFileDeno, ...args: any[]) => Promise<any>,
+  ...args: any[]
+) {
+  Deno.test({
+    name,
+    ignore: Deno.build.os === 'windows',
+    async fn(t) {
+      await t.step('Dangling symlink', async () => {
+        const file = new BIDSFileDeno('tests/data', '/broken-symlink')
+        try {
+          await fn(file, ...args)
+          assert(false, 'Expected error')
+        } catch (e: any) {
+          assertObjectMatch(e, {
+            code: 'FILE_READ',
+            location: '/broken-symlink',
+          })
+          assertArrayIncludes(['NotFound', 'FilesystemLoop'], [e.subCode])
+        }
+      })
+      await t.step('Insufficient permissions', async () => {
+        const tmpfile = await Deno.makeTempFile()
+        await Deno.chmod(tmpfile, 0o000)
+        const file = new BIDSFileDeno('', tmpfile)
+        try {
+          await fn(file, ...args)
+          assert(false, 'Expected error')
+        } catch (e: any) {
+          assertObjectMatch(e, { code: 'FILE_READ', subCode: 'PermissionDenied' })
+        }
+      })
+    },
+  })
+}

bids_validator_deno-2.1.1/src/files/access.ts

@@ -0,0 +1,35 @@
+import { type BIDSFile } from '../types/filetree.ts'
+import { type Issue } from '../types/issues.ts'
+
+function IOErrorToIssue(err: { code: string; name: string }): Issue {
+  const subcode = err.name
+  let issueMessage: string | undefined = undefined
+  if (err.code === 'ENOENT' || err.code === 'ELOOP') {
+    issueMessage = 'Possible dangling symbolic link'
+  }
+  return { code: 'FILE_READ', subCode: err.name, issueMessage }
+}
+
+export function openStream(file: BIDSFile): ReadableStream<Uint8Array<ArrayBuffer>> {
+  try {
+    return file.stream
+  } catch (err: any) {
+    throw { location: file.path, ...IOErrorToIssue(err) }
+  }
+}
+
+export async function readBytes(
+  file: BIDSFile,
+  size: number,
+  offset = 0,
+): Promise<Uint8Array<ArrayBuffer>> {
+  return file.readBytes(size, offset).catch((err: any) => {
+    throw { location: file.path, ...IOErrorToIssue(err) }
+  })
+}
+
+export async function readText(file: BIDSFile): Promise<string> {
+  return file.text().catch((err: any) => {
+    throw { location: file.path, ...IOErrorToIssue(err) }
+  })
+}

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/browser.ts

@@ -29,8 +29,8 @@ export class BIDSFileBrowser implements BIDSFile {
     return this.#file.size
   }
 
-  get stream(): ReadableStream<Uint8Array> {
-    return this.#file.stream()
+  get stream(): ReadableStream<Uint8Array<ArrayBuffer>> {
+    return this.#file.stream() as ReadableStream<Uint8Array<ArrayBuffer>>
   }
 
   get ignored(): boolean {

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/deno.ts

@@ -45,7 +45,7 @@ export class BIDSFileDeno implements BIDSFile {
     return this.#fileInfo ? this.#fileInfo.size : -1
   }
 
-  get stream(): ReadableStream<Uint8Array> {
+  get stream(): ReadableStream<Uint8Array<ArrayBuffer>> {
     const handle = this.#openHandle()
     return handle.readable
   }

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/gzip.test.ts

@@ -1,6 +1,7 @@
 import { assert, assertObjectMatch } from '@std/assert'
 import { parseGzip } from './gzip.ts'
 import { BIDSFileDeno } from './deno.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
 Deno.test('parseGzip', async (t) => {
   await t.step('parses anonymized file', async () => {
@@ -40,3 +41,5 @@ Deno.test('parseGzip', async (t) => {
     assert(!gzip)
   })
 })
+
+testAsyncFileAccess('Test file access errors for parseGzip', parseGzip)

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/gzip.ts

@@ -4,6 +4,7 @@
  */
 import type { Gzip } from '@bids/schema/context'
 import type { BIDSFile } from '../types/filetree.ts'
+import { readBytes } from './access.ts'
 
 /**
  * Parse a gzip header from a file
@@ -19,7 +20,7 @@ export async function parseGzip(
   file: BIDSFile,
   maxBytes: number = 512,
 ): Promise<Gzip | undefined> {
-  const buf = await file.readBytes(maxBytes)
+  const buf = await readBytes(file, maxBytes)
   const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
   if (view.byteLength < 2 || view.getUint16(0, false) !== 0x1f8b) return undefined
 

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/inheritance.test.ts

@@ -72,4 +72,22 @@ Deno.test('walkback inheritance tests', async (t) => {
       assertEquals(rootElectrodes.path, '/space-talairach_electrodes.tsv')
     },
   )
+  await t.step(
+    'The presence of target entities does not trigger exact match logic',
+    async () => {
+      const rootFileTree = pathsToTree([
+        '/sub-01/ieeg/sub-01_task-rest_ieeg.edf',
+        '/sub-01/ieeg/sub-01_task-rest_space-anat_electrodes.tsv',
+        '/sub-01/ieeg/sub-01_task-rest_space-MNI_electrodes.tsv',
+      ])
+      const dataFile = rootFileTree.get('sub-01/ieeg/sub-01_task-rest_ieeg.edf') as BIDSFile
+      const electrodes = walkBack(dataFile, true, ['.tsv'], 'electrodes', ['space'])
+      const localElectrodes: BIDSFile[] = electrodes.next().value
+      assert(Array.isArray(localElectrodes))
+      assertEquals(localElectrodes.map((f) => f.path), [
+        '/sub-01/ieeg/sub-01_task-rest_space-anat_electrodes.tsv',
+        '/sub-01/ieeg/sub-01_task-rest_space-MNI_electrodes.tsv',
+      ])
+    },
+  )
 })

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/inheritance.ts

@@ -50,7 +50,7 @@ export function* walkBack<T extends string[]>(
     if (candidates.length > 1) {
       const exactMatch = candidates.find((file) => {
         const { entities } = readEntities(file.name)
-        return Object.keys(sourceParts.entities).every((entity) =>
+        return [...Object.keys(sourceParts.entities), ...(targetEntities ?? [])].every((entity) =>
           entities[entity] === sourceParts.entities[entity]
         )
       })

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/json.test.ts

@@ -1,7 +1,9 @@
 import { type assert, assertObjectMatch } from '@std/assert'
 import type { BIDSFile } from '../types/filetree.ts'
 import type { FileIgnoreRules } from './ignore.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
+import { pathsToTree } from '../files/filetree.ts'
 import { loadJSON } from './json.ts'
 
 function encodeUTF16(text: string) {
@@ -17,9 +19,12 @@ function encodeUTF16(text: string) {
   return buffer
 }
 
-function makeFile(text: string, encoding: string): BIDSFile {
+function makeFile(path: string, text: string, encoding: string): BIDSFile {
   const bytes = encoding === 'utf-8' ? new TextEncoder().encode(text) : encodeUTF16(text)
+  const file = pathsToTree([path]).get(path) as BIDSFile
   return {
+    path: file.path,
+    parent: file.parent,
     readBytes: async (size: number) => {
       return new Uint8Array(bytes)
     },
@@ -29,13 +34,13 @@ function makeFile(text: string, encoding: string): BIDSFile {
 
 Deno.test('Test JSON error conditions', async (t) => {
   await t.step('Load valid JSON', async () => {
-    const JSONfile = makeFile('{"a": 1}', 'utf-8')
+    const JSONfile = makeFile('/valid-contents.json', '{"a": 1}', 'utf-8')
     const result = await loadJSON(JSONfile)
     assertObjectMatch(result, { a: 1 })
   })
 
   await t.step('Error on BOM', async () => {
-    const BOMfile = makeFile('\uFEFF{"a": 1}', 'utf-8')
+    const BOMfile = makeFile('/BOM.json', '\uFEFF{"a": 1}', 'utf-8')
     let error: any = undefined
     await loadJSON(BOMfile).catch((e) => {
       error = e
@@ -44,7 +49,7 @@ Deno.test('Test JSON error conditions', async (t) => {
   })
 
   await t.step('Error on UTF-16', async () => {
-    const UTF16file = makeFile('{"a": 1}', 'utf-16')
+    const UTF16file = makeFile('/utf16.json', '{"a": 1}', 'utf-16')
     let error: any = undefined
     await loadJSON(UTF16file).catch((e) => {
       error = e
@@ -53,11 +58,14 @@ Deno.test('Test JSON error conditions', async (t) => {
   })
 
   await t.step('Error on invalid JSON syntax', async () => {
-    const badJSON = makeFile('{"a": 1]', 'utf-8')
+    const badJSON = makeFile('/bad-syntax.json', '{"a": 1]', 'utf-8')
     let error: any = undefined
     await loadJSON(badJSON).catch((e) => {
       error = e
     })
     assertObjectMatch(error, { code: 'JSON_INVALID' })
   })
+  loadJSON.cache.clear()
 })
+
+testAsyncFileAccess('Test file access errors for loadJSON', loadJSON)

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/json.ts

@@ -1,4 +1,6 @@
+import { filememoizeAsync } from '../utils/memoize.ts'
 import type { BIDSFile } from '../types/filetree.ts'
+import { readBytes } from './access.ts'
 
 async function readJSONText(file: BIDSFile): Promise<string> {
   // Read JSON text from a file
@@ -6,7 +8,7 @@ async function readJSONText(file: BIDSFile): Promise<string> {
   const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })
   // Streaming TextDecoders are buggy in Deno and Chrome, so read the
   // entire file into memory before decoding and parsing
-  const data = await file.readBytes(file.size)
+  const data = await readBytes(file, file.size)
   try {
     const text = decoder.decode(data)
     if (text.startsWith('\uFEFF')) {
@@ -20,7 +22,7 @@ async function readJSONText(file: BIDSFile): Promise<string> {
   }
 }
 
-export async function loadJSON(file: BIDSFile): Promise<Record<string, unknown>> {
+async function _loadJSON(file: BIDSFile): Promise<Record<string, unknown>> {
   const text = await readJSONText(file) // Raise encoding errors
   let parsedText
   try {
@@ -36,3 +38,5 @@ export async function loadJSON(file: BIDSFile): Promise<Record<string, unknown>>
   }
   return parsedText
 }
+
+export const loadJSON = filememoizeAsync(_loadJSON)

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/nifti.test.ts

@@ -1,8 +1,9 @@
-import { assert, assertObjectMatch } from '@std/assert'
+import { assert, assertEquals, assertObjectMatch } from '@std/assert'
 import { FileIgnoreRules } from './ignore.ts'
 import { BIDSFileDeno } from './deno.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
-import { loadHeader } from './nifti.ts'
+import { axisCodes, loadHeader } from './nifti.ts'
 
 Deno.test('Test loading nifti header', async (t) => {
   const ignore = new FileIgnoreRules([])
@@ -73,3 +74,28 @@ Deno.test('Test loading nifti header', async (t) => {
     })
   })
 })
+
+Deno.test('Test extracting axis codes', async (t) => {
+  await t.step('Identify RAS', async () => {
+    const affine = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['R', 'A', 'S'])
+  })
+  await t.step('Identify LPS (flips)', async () => {
+    const affine = [[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['L', 'P', 'S'])
+  })
+  await t.step('Identify SPL (flips + swap)', async () => {
+    const affine = [[0, 0, -1, 0], [0, -1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['S', 'P', 'L'])
+  })
+  await t.step('Identify SLP (flips + rotate)', async () => {
+    const affine = [[0, -1, 0, 0], [0, 0, -1, 0], [1, 0, 0, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['S', 'L', 'P'])
+  })
+  await t.step('Identify ASR (rotate)', async () => {
+    const affine = [[0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['A', 'S', 'R'])
+  })
+})
+
+testAsyncFileAccess('Test file access errors for loadHeader', loadHeader)

bids_validator_deno-2.1.1/src/files/nifti.ts

@@ -0,0 +1,157 @@
+import { isCompressed, isNIFTI1, isNIFTI2, NIFTI1, NIFTI2 } from '@mango/nifti'
+import type { BIDSFile } from '../types/filetree.ts'
+import { logger } from '../utils/logger.ts'
+import type { NiftiHeader } from '@bids/schema/context'
+import { readBytes } from './access.ts'
+
+async function extract(buffer: Uint8Array, nbytes: number): Promise<Uint8Array<ArrayBuffer>> {
+  // The fflate decompression that is used in nifti-reader does not like
+  // truncated data, so pretend that we have a stream and stop reading
+  // when we have enough bytes.
+  const result = new Uint8Array(nbytes)
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(buffer)
+      controller.close()
+    },
+  })
+  const reader = stream.pipeThrough(new DecompressionStream('gzip')).getReader()
+  let offset = 0
+  try {
+    while (offset < nbytes) {
+      const { value, done } = await reader.read()
+      if (done || !value) {
+        break
+      }
+      result.set(value.subarray(0, Math.min(value.length, nbytes - offset)), offset)
+      offset += value.length
+    }
+  } finally {
+    await reader.cancel()
+  }
+  return result.subarray(0, offset)
+}
+
+export async function loadHeader(file: BIDSFile): Promise<NiftiHeader> {
+  const buf = await readBytes(file, 1024)
+  try {
+    const data = isCompressed(buf.buffer) ? await extract(buf, 540) : buf.slice(0, 540)
+    let header
+    if (isNIFTI1(data.buffer)) {
+      header = new NIFTI1()
+      // Truncate to 348 bytes to avoid attempting to parse extensions
+      header.readHeader(data.buffer.slice(0, 348))
+    } else if (isNIFTI2(data.buffer)) {
+      header = new NIFTI2()
+      header.readHeader(data.buffer)
+    }
+    if (!header) {
+      throw { code: 'NIFTI_HEADER_UNREADABLE' }
+    }
+    const ndim = header.dims[0]
+    return {
+      dim: header.dims,
+      // Hack: round pixdim to 3 decimal places; schema should add rounding function
+      pixdim: header.pixDims.map((pixdim) => Math.round(pixdim * 1000) / 1000),
+      shape: header.dims.slice(1, ndim + 1),
+      voxel_sizes: header.pixDims.slice(1, ndim + 1),
+      dim_info: {
+        freq: header.dim_info & 0x03,
+        phase: (header.dim_info >> 2) & 0x03,
+        slice: (header.dim_info >> 4) & 0x03,
+      },
+      xyzt_units: {
+        xyz: ['unknown', 'meter', 'mm', 'um'][header.xyzt_units & 0x03],
+        t: ['unknown', 'sec', 'msec', 'usec'][(header.xyzt_units >> 3) & 0x03],
+      },
+      qform_code: header.qform_code,
+      sform_code: header.sform_code,
+      axis_codes: axisCodes(header.affine),
+    } as NiftiHeader
+  } catch (err) {
+    throw { code: 'NIFTI_HEADER_UNREADABLE' }
+  }
+}
+
+/** Vector addition */
+function add(a: number[], b: number[]): number[] {
+  return a.map((x, i) => x + b[i])
+}
+
+/** Vector subtraction */
+function sub(a: number[], b: number[]): number[] {
+  return a.map((x, i) => x - b[i])
+}
+
+/** Scalar multiplication */
+function scale(vec: number[], scalar: number): number[] {
+  return vec.map((x) => x * scalar)
+}
+
+/** Dot product */
+function dot(a: number[], b: number[]): number {
+  return a.map((x, i) => x * b[i]).reduce((acc, x) => acc + x, 0)
+}
+
+function argMax(arr: number[]): number {
+  return arr.reduce((acc, x, i) => (x > arr[acc] ? i : acc), 0)
+}
+
+/**
+ * Identify the nearest principle axes of an image affine.
+ *
+ * Affines transform indices in a data array into mm right, anterior and superior of
+ * an origin in "world coordinates". If moving along an axis in the positive direction
+ * predominantly moves right, that axis is labeled "R".
+ *
+ * @example The identity matrix is in "RAS" orientation:
+ *
+ * # Usage
+ *
+ * ```ts
+ * const affine = [[1, 0, 0, 0],
+ *                 [0, 1, 0, 0],
+ *                 [0, 0, 1, 0],
+ *                 [0, 0, 0, 1]]
+ *
+ * axisCodes(affine)
+ * ```
+ *
+ * # Result
+ * ```ts
+ * ['R', 'A', 'S']
+ * ```
+ *
+ * @returns character codes describing the orientation of an image affine.
+ */
+export function axisCodes(affine: number[][]): string[] {
+  // This function is an extract of the Python function transforms3d.affines.decompose44
+  // (https://github.com/matthew-brett/transforms3d/blob/6a43a98/transforms3d/affines.py#L10-L153)
+  //
+  // As an optimization, this only orthogonalizes the basis,
+  // and does not normalize to unit vectors.
+
+  // Operate on columns, which are the cosines that project input coordinates onto output axes
+  const [cosX, cosY, cosZ] = [0, 1, 2].map((j) => [0, 1, 2].map((i) => affine[i][j]))
+
+  // Orthogonalize cosY with respect to cosX
+  const orthY = sub(cosY, scale(cosX, dot(cosX, cosY)))
+
+  // Orthogonalize cosZ with respect to cosX and orthY
+  const orthZ = sub(
+    cosZ,
+    add(scale(cosX, dot(cosX, cosZ)), scale(orthY, dot(orthY, cosZ))),
+  )
+
+  const basis = [cosX, orthY, orthZ]
+  const maxIndices = basis.map((row) => argMax(row.map(Math.abs)))
+
+  // Check that indices are 0, 1 and 2 in some order
+  if (maxIndices.toSorted().some((idx, i) => idx !== i)) {
+    throw { key: 'AMBIGUOUS_AFFINE' }
+  }
+
+  // Positive/negative codes for each world axis
+  const codes = ['RL', 'AP', 'SI']
+  return maxIndices.map((idx, i) => codes[idx][basis[i][idx] > 0 ? 0 : 1])
+}

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/streams.ts

@@ -8,6 +8,16 @@ export class UnicodeDecodeError extends Error {
   }
 }
 
+const _decode = TextDecoder.prototype.decode
+
+TextDecoder.prototype.decode = function (input, options) {
+  try {
+    return _decode.call(this, input, options)
+  } catch (error) {
+    throw { code: 'INVALID_FILE_ENCODING', message: error }
+  }
+}
+
 /**
  * A transformer that ensures the input stream is valid UTF-8 and throws
  * a UnicodeDecodeError if UTF-16 BOM is detected
@@ -16,15 +26,15 @@ export class UTF8StreamTransformer implements Transformer<Uint8Array, string> {
   private decoder: TextDecoder
   private firstChunk: boolean
 
-  constructor() {
-    this.decoder = new TextDecoder('utf-8')
+  constructor(options = { fatal: false }) {
+    this.decoder = new TextDecoder('utf-8', options)
     this.firstChunk = true
   }
 
   transform(chunk: Uint8Array, controller: TransformStreamDefaultController<string>) {
     // Check first chunk for UTF-16 BOM
     if (this.firstChunk) {
-      const decoded = this.decoder.decode(chunk, { stream: true })
+      let decoded = this.decoder.decode(chunk, { stream: true })
       if (decoded.startsWith('\uFFFD')) {
         throw new UnicodeDecodeError('This file appears to be UTF-16')
       }
@@ -46,6 +56,6 @@ export class UTF8StreamTransformer implements Transformer<Uint8Array, string> {
 /**
  * Creates a TransformStream that validates and decodes UTF-8 text
  */
-export function createUTF8Stream() {
-  return new TransformStream(new UTF8StreamTransformer())
+export function createUTF8Stream(options = { fatal: false }) {
+  return new TransformStream(new UTF8StreamTransformer(options))
 }

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/tiff.test.ts

@@ -1,6 +1,7 @@
 import { assert, assertObjectMatch } from '@std/assert'
 import { parseTIFF } from './tiff.ts'
 import { BIDSFileDeno } from './deno.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
 Deno.test('parseTIFF', async (t) => {
   await t.step('parse example file as TIFF', async () => {
@@ -53,3 +54,5 @@ Deno.test('parseTIFF', async (t) => {
     })
   })
 })
+
+testAsyncFileAccess('Test file access errors for parseTIFF', parseTIFF)

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.1}/src/files/tiff.ts

@@ -5,6 +5,7 @@
 import type { Ome, Tiff } from '@bids/schema/context'
 import * as XML from '@libs/xml'
 import type { BIDSFile } from '../types/filetree.ts'
+import { readBytes } from './access.ts'
 
 function getImageDescription(
   dataview: DataView<ArrayBuffer>,
@@ -44,7 +45,7 @@ export async function parseTIFF(
   file: BIDSFile,
   OME: boolean,
 ): Promise<{ tiff?: Tiff; ome?: Ome }> {
-  const buf = await file.readBytes(4096)
+  const buf = await readBytes(file, 4096)
   const dataview = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
   const magic = dataview.getUint16(0, true)
   const littleEndian = magic === 0x4949