chore: not dynamic imports flagged

Author: vasco-santos

packages/ipfs-unixfs-exporter/src/resolvers/index.js

@@ -5,34 +5,31 @@ import * as dagCbor from '@ipld/dag-cbor'
 import * as raw from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
 
+import dagPbResolver from './unixfs-v1/index.js'
+import rawResolver from './raw.js'
+import dagCborResolver from './dag-cbor.js'
+import identifyResolver from './identity.js'
+
 /**
  * @typedef {import('../types').Resolver} Resolver
  * @typedef {import('../types').Resolve} Resolve
  */
 
 /**
- * @param {number} key
- * @returns {Promise<Resolver|undefined>}
+ * @type {{ [ key: string ]: Resolver }}
  */
-const importResolver = async (key) => {
-  switch (key) {
-    case dagPb.code:
-      return (await (import('./unixfs-v1/index.js'))).default
-    case raw.code:
-      return (await (import('./raw.js'))).default
-    case dagCbor.code:
-      return (await (import('./dag-cbor.js'))).default
-    case identity.code:
-      return (await (import('./identity.js'))).default
-    default:
-  }
+const resolvers = {
+  [dagPb.code]: dagPbResolver,
+  [raw.code]: rawResolver,
+  [dagCbor.code]: dagCborResolver,
+  [identity.code]: identifyResolver
 }
 
 /**
  * @type {Resolve}
  */
-async function resolve (cid, name, path, toResolve, depth, blockstore, options) {
-  const resolver = await importResolver(cid.code)
+function resolve (cid, name, path, toResolve, depth, blockstore, options) {
+  const resolver = resolvers[cid.code]
 
   if (!resolver) {
     throw errCode(new Error(`No resolver for code ${cid.code}`), 'ERR_NO_RESOLVER')

packages/ipfs-unixfs-exporter/src/resolvers/unixfs-v1/index.js

@@ -3,6 +3,10 @@ import { UnixFS } from 'ipfs-unixfs'
 import findShardCid from '../../utils/find-cid-in-shard.js'
 import { decode } from '@ipld/dag-pb'
 
+import contentFile from './content/file.js'
+import contentDirectory from './content/directory.js'
+import contentHamtShardedDirectory from './content/hamt-sharded-directory.js'
+
 /**
  * @typedef {import('../../types').Resolve} Resolve
  * @typedef {import('../../types').Resolver} Resolver
@@ -21,22 +25,18 @@ const findLinkCid = (node, name) => {
 }
 
 /**
- * @param {string} key
- * @returns {Promise<UnixfsV1Resolver|undefined>}
+ * @type {{ [key: string]: UnixfsV1Resolver }}
  */
-const importContentExporters = async (key) => {
-  switch (key) {
-    case 'raw':
-    case 'file':
-      return (await (import('./content/file.js'))).default
-    case 'directory':
-      return (await (import('./content/directory.js'))).default
-    case 'hamt-sharded-directory':
-      return (await (import('./content/hamt-sharded-directory.js'))).default
-    case 'metadata':
-    case 'symlink':
-      return () => () => []
-    default:
+const contentExporters = {
+  raw: contentFile,
+  file: contentFile,
+  directory: contentDirectory,
+  'hamt-sharded-directory': contentHamtShardedDirectory,
+  metadata: (cid, node, unixfs, path, resolve, depth, blockstore) => {
+    return () => []
+  },
+  symlink: (cid, node, unixfs, path, resolve, depth, blockstore) => {
+    return () => []
   }
 }
 
@@ -94,16 +94,14 @@ const unixFsResolver = async (cid, name, path, toResolve, resolve, depth, blocks
     }
   }
 
-  const contentExporter = await importContentExporters(unixfs.type)
-
   return {
     entry: {
       type: unixfs.isDirectory() ? 'directory' : 'file',
       name,
       path,
       cid,
       // @ts-ignore
-      content: contentExporter(cid, node, unixfs, path, resolve, depth, blockstore),
+      content: contentExporters[unixfs.type](cid, node, unixfs, path, resolve, depth, blockstore),
       unixfs,
       depth,
       node,

packages/ipfs-unixfs-importer/src/dag-builder/file/index.js

@@ -6,6 +6,10 @@ import parallelBatch from 'it-parallel-batch'
 import * as rawCodec from 'multiformats/codecs/raw'
 import * as dagPb from '@ipld/dag-pb'
 
+import dagFlat from './flat.js'
+import dagBalanced from './balanced.js'
+import dagTrickle from './trickle.js'
+
 /**
  * @typedef {import('interface-blockstore').Blockstore} Blockstore
  * @typedef {import('../../types').File} File
@@ -16,19 +20,12 @@ import * as dagPb from '@ipld/dag-pb'
  */
 
 /**
- * @param {string} key
- * @returns {Promise<FileDAGBuilder|undefined>}
+ * @type {{ [key: string]: FileDAGBuilder}}
  */
-const importDagBuilder = async (key) => {
-  switch (key) {
-    case 'flat':
-      return (await (import('./flat.js'))).default
-    case 'balanced':
-      return (await (import('./balanced.js'))).default
-    case 'trickle':
-      return (await (import('./trickle.js'))).default
-    default:
-  }
+const dagBuilders = {
+  flat: dagFlat,
+  balanced: dagBalanced,
+  trickle: dagTrickle
 }
 
 /**
@@ -197,8 +194,8 @@ const reduce = (file, blockstore, options) => {
 /**
  * @type {import('../../types').UnixFSV1DagBuilder<File>}
  */
-async function fileBuilder (file, block, options) {
-  const dagBuilder = await importDagBuilder(options.strategy)
+function fileBuilder (file, block, options) {
+  const dagBuilder = dagBuilders[options.strategy]
 
   if (!dagBuilder) {
     throw errCode(new Error(`Unknown importer build strategy name: ${options.strategy}`), 'ERR_BAD_STRATEGY')