*Rewrite to use kernel client library

*Use new IPFS API

package.json

@@ -4,13 +4,14 @@
     "type": "module",
     "main": "dist/index.js",
     "dependencies": {
-        "is-ipfs": "^6.0.2",
+        "@lumeweb/libkernel-universal": "git+https://git.lumeweb.com/LumeWeb/libkernel-universal.git",
         "libkernel": "^0.1.43",
-        "libkmodule": "^0.2.44"
+        "libkmodule": "^0.2.44",
+        "p-defer": "^4.0.0"
     },
     "devDependencies": {
         "@types/node": "^18.0.6",
-        "libskynet": "^0.0.62",
+        "prettier": "^2.7.1",
-        "prettier": "^2.7.1"
+        "typescript": "^5.0.3"
     }
 }

src/index.ts

@@ -1,90 +1,71 @@
-import type { DataFn } from "libskynet";
+import { Client, factory } from "@lumeweb/libkernel-universal";
-import { ipnsPath, ipfsPath } from "is-ipfs";
+import defer from "p-defer";
 
-const IPFS_MODULE = "AQDr2iGYEiMKIdb14w7dxwxFYBo3LaYc0mAuRKXsF2w9OQ";
+interface AbortableGenerator {
+  abort: () => void;
+  iterable: AsyncGenerator<object>;
+}
 
-let callModule: any, connectModule: any;
+export class IPFSClient extends Client {
-
+  public async ready() {
-async function loadLibs() {
+    return this.callModuleReturn("ready");
-  if (callModule && connectModule) {
-    return;
   }
-  if (typeof window !== "undefined" && window?.document) {
+
-    const pkg = await import("libkernel");
+  public async stat(cid: string) {
-    callModule = pkg.callModule;
+    return this.callModuleReturn("stat");
-    connectModule = pkg.connectModule;
+  }
-  } else {
+
-    const pkg = await import("libkmodule");
+  public ls(cid: string): AbortableGenerator {
-    callModule = pkg.callModule;
+    return this.connectModuleGenerator("ls", { cid });
-    connectModule = pkg.connectModule;
+  }
+
+  public cat(cid: string): AbortableGenerator {
+    return this.connectModuleGenerator("cat", { cid });
+  }
+
+  public async ipns(cid: string): Promise<string> {
+    return this.callModuleReturn("ipnsResolve");
+  }
+
+  public async activePeers(): Promise<number> {
+    return this.callModuleReturn("getActivePeers");
+  }
+
+  private connectModuleGenerator(
+    method: string,
+    data: any
+  ): AbortableGenerator {
+    const pipe = defer();
+
+    let done = false;
+
+    const [update, result] = this.connectModule(method, data, (item: any) => {
+      pipe.resolve(item);
+    });
+
+    (async () => {
+      const ret = await result;
+      done = true;
+      this.handleError(ret);
+    })();
+
+    return {
+      abort() {
+        update();
+      },
+      // @ts-ignore
+      iterable: async function* (): AsyncGenerator<object> {
+        // @ts-ignore
+        const iterator = (await pipe.promise)[Symbol.asyncIterator]();
+        for await (const value of iterator) {
+          yield value as object;
+        }
+      },
+    };
   }
 }
 
-export async function refreshGatewayList() {
+export const createClient = factory<IPFSClient>(
-  const [resp, err] = await doCall("refreshGatewayList");
+  IPFSClient,
-
+  "_AkimjN5qo5cYklxdBNszsxh6VXgypNZVq4zk_BIS3s76A"
-  if (err) {
+);
-    throw new Error(err);
-  }
-
-  return resp;
-}
-
-export async function fetchIpfs(
-  hash: string,
-  path = "",
-  receiveUpdate: DataFn
-) {
-  if (!ipfsPath(`/ipfs/${hash}`)) {
-    throw new Error("Invalid hash");
-  }
-  return doFetch("fetchIpfs", { hash, path }, receiveUpdate);
-}
-
-export async function statIpfs(hash: string, path = "") {
-  if (!ipfsPath(`/ipfs/${hash}`)) {
-    throw new Error("Invalid hash");
-  }
-  return doFetch("statIpfs", { hash, path });
-}
-
-export async function fetchIpns(
-  hash: string,
-  path = "",
-  receiveUpdate: DataFn
-) {
-  if (!ipnsPath(`/ipns/{${hash}`)) {
-    throw new Error("Invalid hash");
-  }
-  return doFetch("fetchIpns", { hash, path }, receiveUpdate);
-}
-
-export async function statIpns(hash: string, path = "") {
-  if (!ipnsPath(`/ipns/{${hash}`)) {
-    throw new Error("Invalid hash");
-  }
-  return doFetch("statIpns", { hash, path });
-}
-
-async function doFetch(method: string, data: any, receiveUpdate?: DataFn) {
-  let [resp, err] = await doCall(method, data, receiveUpdate);
-
-  if (typeof err?.then === "function") {
-    [resp, err] = await err;
-  }
-
-  if (err) {
-    throw new Error(err);
-  }
-
-  return resp;
-}
-
-async function doCall(method: string, data?: any, receiveUpdate?: DataFn) {
-  await loadLibs();
-  if (receiveUpdate) {
-    return connectModule(IPFS_MODULE, method, data, receiveUpdate);
-  }
-
-  return callModule(IPFS_MODULE, method, data);
-}