chore: revert formatting changes

achingbrain · achingbrain · commit da5659468f3c · 2025-06-18T08:14:34.000+03:00
diff --git a/packages/ipfs-unixfs-importer/src/dag-builder/dir.ts b/packages/ipfs-unixfs-importer/src/dag-builder/dir.ts
@@ -1,11 +1,7 @@
 import { encode, prepare } from '@ipld/dag-pb'
 import { UnixFS } from 'ipfs-unixfs'
 import { persist } from '../utils/persist.js'
-import type {
-  Directory,
-  InProgressImportResult,
-  WritableStorage
-} from '../index.js'
+import type { Directory, InProgressImportResult, WritableStorage } from '../index.js'
 import type { Version } from 'multiformats/cid'
 
 export interface DirBuilderOptions {
@@ -14,18 +10,10 @@ export interface DirBuilderOptions {
 }
 
 export interface DirBuilder {
-  (
-    dir: Directory,
-    blockstore: WritableStorage,
-    options: DirBuilderOptions
-  ): Promise<InProgressImportResult>
+  (dir: Directory, blockstore: WritableStorage, options: DirBuilderOptions): Promise<InProgressImportResult>
 }
 
-export const defaultDirBuilder = async (
-  dir: Directory,
-  blockstore: WritableStorage,
-  options: DirBuilderOptions
-): Promise<InProgressImportResult> => {
+export const defaultDirBuilder: DirBuilder = async (dir: Directory, blockstore: WritableStorage, options: DirBuilderOptions): Promise<InProgressImportResult> => {
   const unixfs = new UnixFS({
     type: 'directory',
     mtime: dir.mtime,
diff --git a/packages/ipfs-unixfs-importer/src/dag-builder/file.ts b/packages/ipfs-unixfs-importer/src/dag-builder/file.ts
@@ -4,14 +4,7 @@ import parallelBatch from 'it-parallel-batch'
 import * as rawCodec from 'multiformats/codecs/raw'
 import { CustomProgressEvent } from 'progress-events'
 import { persist } from '../utils/persist.js'
-import type {
-  BufferImporter,
-  File,
-  InProgressImportResult,
-  WritableStorage,
-  SingleBlockImportResult,
-  ImporterProgressEvents
-} from '../index.js'
+import type { BufferImporter, File, InProgressImportResult, WritableStorage, SingleBlockImportResult, ImporterProgressEvents } from '../index.js'
 import type { FileLayout, Reducer } from '../layout/index.js'
 import type { PBLink, PBNode } from '@ipld/dag-pb'
 import type { CID, Version } from 'multiformats/cid'
@@ -22,18 +15,11 @@ interface BuildFileBatchOptions {
   blockWriteConcurrency: number
 }
 
-async function * buildFileBatch (
-  file: File,
-  blockstore: WritableStorage,
-  options: BuildFileBatchOptions
-): AsyncGenerator<InProgressImportResult> {
+async function * buildFileBatch (file: File, blockstore: WritableStorage, options: BuildFileBatchOptions): AsyncGenerator<InProgressImportResult> {
   let count = -1
   let previous: SingleBlockImportResult | undefined
 
-  for await (const entry of parallelBatch(
-    options.bufferImporter(file, blockstore),
-    options.blockWriteConcurrency
-  )) {
+  for await (const entry of parallelBatch(options.bufferImporter(file, blockstore), options.blockWriteConcurrency)) {
     count++
 
     if (count === 0) {
@@ -78,10 +64,8 @@ export interface LayoutLeafProgress {
   path?: string
 }
 
-export type ReducerProgressEvents = ProgressEvent<
-'unixfs:importer:progress:file:layout',
-LayoutLeafProgress
->
+export type ReducerProgressEvents =
+  ProgressEvent<'unixfs:importer:progress:file:layout', LayoutLeafProgress>
 
 interface ReduceOptions extends ProgressOptions<ImporterProgressEvents> {
   reduceSingleLeafToSelf: boolean
@@ -93,24 +77,13 @@ function isSingleBlockImport (result: any): result is SingleBlockImportResult {
   return result.single === true
 }
 
-const reduce = (
-  file: File,
-  blockstore: WritableStorage,
-  options: ReduceOptions
-): Reducer => {
+const reduce = (file: File, blockstore: WritableStorage, options: ReduceOptions): Reducer => {
   const reducer: Reducer = async function (leaves) {
-    if (
-      leaves.length === 1 &&
-      isSingleBlockImport(leaves[0]) &&
-      options.reduceSingleLeafToSelf
-    ) {
+    if (leaves.length === 1 && isSingleBlockImport(leaves[0]) && options.reduceSingleLeafToSelf) {
       const leaf = leaves[0]
       let node: Uint8Array | PBNode = leaf.block
 
-      if (
-        isSingleBlockImport(leaf) &&
-        (file.mtime !== undefined || file.mode !== undefined)
-      ) {
+      if (isSingleBlockImport(leaf) && (file.mtime !== undefined || file.mode !== undefined)) {
         // only one leaf node which is a raw leaf - we have metadata so convert it into a
         // UnixFS entry otherwise we'll have nowhere to store the metadata
         leaf.unixfs = new UnixFS({
@@ -132,13 +105,10 @@ const reduce = (
       }
 
       options.onProgress?.(
-        new CustomProgressEvent<LayoutLeafProgress>(
-          'unixfs:importer:progress:file:layout',
-          {
-            cid: leaf.cid,
-            path: leaf.originalPath
-          }
-        )
+        new CustomProgressEvent<LayoutLeafProgress>('unixfs:importer:progress:file:layout', {
+          cid: leaf.cid,
+          path: leaf.originalPath
+        })
       )
 
       return {
@@ -163,11 +133,7 @@ const reduce = (
           return true
         }
 
-        if (
-          leaf.unixfs != null &&
-          leaf.unixfs.data == null &&
-          leaf.unixfs.fileSize() > 0n
-        ) {
+        if (leaf.unixfs != null && leaf.unixfs.data == null && leaf.unixfs.fileSize() > 0n) {
           return true
         }
 
@@ -208,13 +174,10 @@ const reduce = (
     const cid = await persist(block, blockstore, options)
 
     options.onProgress?.(
-      new CustomProgressEvent<LayoutLeafProgress>(
-        'unixfs:importer:progress:file:layout',
-        {
-          cid,
-          path: file.originalPath
-        }
-      )
+      new CustomProgressEvent<LayoutLeafProgress>('unixfs:importer:progress:file:layout', {
+        cid,
+        path: file.originalPath
+      })
     )
 
     return {
@@ -234,24 +197,14 @@ const reduce = (
 }
 
 export interface FileBuilder {
-  (
-    file: File,
-    blockstore: WritableStorage,
-    options: FileBuilderOptions
-  ): Promise<InProgressImportResult>
+  (file: File, blockstore: WritableStorage, options: FileBuilderOptions): Promise<InProgressImportResult>
 }
 
-export interface FileBuilderOptions
-  extends BuildFileBatchOptions,
-  ReduceOptions {
+export interface FileBuilderOptions extends BuildFileBatchOptions, ReduceOptions {
   layout: FileLayout
 }
 
-export const defaultFileBuilder = async (
-  file: File,
-  block: WritableStorage,
-  options: FileBuilderOptions
-): Promise<InProgressImportResult> => {
+export const defaultFileBuilder: FileBuilder = async (file: File, block: WritableStorage, options: FileBuilderOptions): Promise<InProgressImportResult> => {
   return options.layout(
     buildFileBatch(file, block, options),
     reduce(file, block, options)
diff --git a/packages/ipfs-unixfs-importer/src/dag-builder/index.ts b/packages/ipfs-unixfs-importer/src/dag-builder/index.ts
@@ -6,15 +6,7 @@ import type { DirBuilder, DirBuilderOptions } from './dir.js'
 import type { FileBuilder, FileBuilderOptions } from './file.js'
 import type { ChunkValidator } from './validate-chunks.js'
 import type { Chunker } from '../chunker/index.js'
-import type {
-  Directory,
-  File,
-  FileCandidate,
-  ImportCandidate,
-  ImporterProgressEvents,
-  InProgressImportResult,
-  WritableStorage
-} from '../index.js'
+import type { Directory, File, FileCandidate, ImportCandidate, ImporterProgressEvents, InProgressImportResult, WritableStorage } from '../index.js'
 import type { ProgressEvent, ProgressOptions } from 'progress-events'
 
 /**
@@ -37,10 +29,8 @@ export interface ImportReadProgress {
   path?: string
 }
 
-export type DagBuilderProgressEvents = ProgressEvent<
-'unixfs:importer:progress:file:read',
-ImportReadProgress
->
+export type DagBuilderProgressEvents =
+  ProgressEvent<'unixfs:importer:progress:file:read', ImportReadProgress>
 
 function isIterable (thing: any): thing is Iterable<any> {
   return Symbol.iterator in thing
@@ -50,9 +40,7 @@ function isAsyncIterable (thing: any): thing is AsyncIterable<any> {
   return Symbol.asyncIterator in thing
 }
 
-function contentAsAsyncIterable (
-  content: Uint8Array | AsyncIterable<Uint8Array> | Iterable<Uint8Array>
-): AsyncIterable<Uint8Array> {
+function contentAsAsyncIterable (content: Uint8Array | AsyncIterable<Uint8Array> | Iterable<Uint8Array>): AsyncIterable<Uint8Array> {
   try {
     if (content instanceof Uint8Array) {
       return (async function * () {
@@ -72,10 +60,7 @@ function contentAsAsyncIterable (
   throw new InvalidContentError('Content was invalid')
 }
 
-export interface DagBuilderOptions
-  extends FileBuilderOptions,
-  DirBuilderOptions,
-  ProgressOptions<ImporterProgressEvents> {
+export interface DagBuilderOptions extends FileBuilderOptions, DirBuilderOptions, ProgressOptions<ImporterProgressEvents> {
   chunker: Chunker
   chunkValidator: ChunkValidator
   wrapWithDirectory: boolean
@@ -88,9 +73,7 @@ export type ImporterSourceStream =
   | Iterable<ImportCandidate>
 
 export interface DAGBuilder {
-  (source: ImporterSourceStream, blockstore: WritableStorage): AsyncIterable<
-  () => Promise<InProgressImportResult>
-  >
+  (source: ImporterSourceStream, blockstore: WritableStorage): AsyncIterable<() => Promise<InProgressImportResult>>
 }
 
 export function defaultDagBuilder (options: DagBuilderOptions): DAGBuilder {
@@ -102,7 +85,7 @@ export function defaultDagBuilder (options: DagBuilderOptions): DAGBuilder {
         originalPath = entry.path
         entry.path = entry.path
           .split('/')
-          .filter((path) => path != null && path !== '.')
+          .filter(path => path != null && path !== '.')
           .join('/')
       }
 
@@ -114,22 +97,15 @@ export function defaultDagBuilder (options: DagBuilderOptions): DAGBuilder {
           content: (async function * () {
             let bytesRead = 0n
 
-            for await (const chunk of options.chunker(
-              options.chunkValidator(contentAsAsyncIterable(entry.content))
-            )) {
+            for await (const chunk of options.chunker(options.chunkValidator(contentAsAsyncIterable(entry.content)))) {
               const currentChunkSize = BigInt(chunk.byteLength)
               bytesRead += currentChunkSize
 
-              options.onProgress?.(
-                new CustomProgressEvent<ImportReadProgress>(
-                  'unixfs:importer:progress:file:read',
-                  {
-                    bytesRead,
-                    chunkSize: currentChunkSize,
-                    path: entry.path
-                  }
-                )
-              )
+              options.onProgress?.(new CustomProgressEvent<ImportReadProgress>('unixfs:importer:progress:file:read', {
+                bytesRead,
+                chunkSize: currentChunkSize,
+                path: entry.path
+              }))
 
               yield chunk
             }
@@ -148,9 +124,7 @@ export function defaultDagBuilder (options: DagBuilderOptions): DAGBuilder {
           originalPath
         }
 
-        const dirBuilder =
-          options.dirBuilder ??
-          defaultDirBuilder
+        const dirBuilder = options.dirBuilder ?? defaultDirBuilder
 
         yield async () => dirBuilder(dir, blockstore, options)
       } else {
diff --git a/packages/ipfs-unixfs-importer/test/custom-dag-builder-params.spec.ts b/packages/ipfs-unixfs-importer/test/custom-dag-builder-params.spec.ts
@@ -1,10 +1,7 @@
-import { chai } from 'aegir/chai'
+import { expect } from 'aegir/chai'
 import { MemoryBlockstore } from 'blockstore-core'
 import { defaultDirBuilder } from '../src/dag-builder/dir.js'
-import {
-  defaultFileBuilder
-
-} from '../src/dag-builder/file.js'
+import { defaultFileBuilder } from '../src/dag-builder/file.js'
 import { importer } from '../src/index.js'
 import type { DirBuilder } from '../src/dag-builder/dir.js'
 import type { FileBuilder } from '../src/dag-builder/file.js'
@@ -24,27 +21,20 @@ describe('CustomParamsDagBuilder', () => {
 
     const blockstore = new MemoryBlockstore()
     const files = []
-    for await (const file of importer(
-      [
-        {
-          path: './src/file.txt',
-          content: new Uint8Array(
-            'hello world'.split('').map((char) => char.charCodeAt(0))
-          )
-        },
-        {
-          path: './src'
-        }
-      ],
-      blockstore,
-      {
-        dirBuilder: customDirBuilder,
-        fileBuilder: customFileBuilder
-      }
-    )) {
+    for await (const file of importer([{
+      path: './src/file.txt',
+      content: new Uint8Array(
+        'hello world'.split('').map((char) => char.charCodeAt(0))
+      )
+    }, {
+      path: './src'
+    }], blockstore, {
+      dirBuilder: customDirBuilder,
+      fileBuilder: customFileBuilder
+    })) {
       files.push(file)
     }
 
-    chai.expect(counter.dirCounter).to.equal(1)
+    expect(counter.dirCounter).to.equal(1)
   })
 })
