How to use the node-localstorage.LocalStorage function in node-localstorage

html: undefined,
    src: fs.readFileSync('./node_modules/jquery/dist/jquery.js', 'utf-8')
});

global.fs = fs;
global.chai = chai;
// global.adm = adm;

// 使用 chai.expect 断言
chai.expect();
global.expect = chai.expect;

// localStorage
const LocalStorage = require('node-localstorage').LocalStorage;

global.localStorage = new LocalStorage('./test/localStorageTemp');
before(function (next) {
    global.adm = require('../../src/adm.jquery.js');
    global.window = document.defaultView;
    global.localStorage = global.localStorage || new LocalStorage('./test/localStorageTemp');
    global.window.localStorage = global.localStorage;

    next();
});

// import test from 'ava';
// global.test = test;

// global.document = jsdom('<p></p>');
// global.window = document.defaultView;
// global.navigator = window.navigator;

console.log(
    "Usage: ./make-bot --workspace workspaceId --id botId bot-code.js",
  )
  process.exit(0)
}

const code = fs.readFileSync(fileName, "utf-8")

import { LocalStorage } from "node-localstorage"

interface Global {
  localStorage: LocalStorage
}
declare var global: Global

global.localStorage = new LocalStorage("./localstorage")

const raf = require("random-access-file")
import { Doc } from "automerge/frontend"
import { last, once } from "lodash"

import * as Link from "../../data/Link"
import Store from "../../data/Store"
import StoreBackend from "../../data/StoreBackend"

import CloudClient from "discovery-cloud/Client"
import { Hypermerge, FrontendManager } from "hypermerge"

import "./Bot" // we have local bot implementation since the Capstone one uses css imports
import * as Board from "../../components/Board"
import * as DataImport from "../../components/DataImport"
import * as Workspace from "../../components/Workspace"

/*global module, require*/

var tgv = tgv || {};

// Node.js detection. For testing
if (typeof module !== 'undefined' && module.exports) {
  tgv.utils = require('../utils.js');
  var LocalStorage = require('node-localstorage').LocalStorage,
      localStorage = new LocalStorage('./nodeLocalStorage');
}

(function(utils) {

  var AppModel = function(options) {
    this._init = this._init.bind(this);
    this.getClickRadius = this.getClickRadius.bind(this);
    this.getMapClickEnabled = this.getMapClickEnabled.bind(this);
    this.setClickRadius = this.setClickRadius.bind(this);
    this.setMapClickEnabled = this.setMapClickEnabled.bind(this);
    this.getClickRadiusMeters = this.getClickRadiusMeters.bind(this);

    // get default values from localStorage if they are available
    var defaults = {
      clickRadius: 250,
      mapClickEnabled: true

swapAuth: {
      ...common.swapAuth,
      ...config.swapAuth,
      ...custom.swapAuth,
    },

    swapRoom: {
      ...common.swapRoom,
      ...config.swapRoom,
      ...custom.swapRoom,
    },
  }

  setupLocalStorage()

  const storage = new LocalStorage(config.storageDir)

  const web3    = eth[config.network]().core
  const bitcoin = btc[config.network]().core

  const tokens = (config.ERC20TOKENS || [])
    .map(_token => ({ network: config.network, ..._token }))
    .filter(_token => _token.network === config.network)

  return {
    network: config.network,
    constants,
    env: {
      web3,
      bitcoin,
      // bcash,
      Ipfs,

cacheDeviceKeyAndPassword() {
    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}.${this.username}`;
    const deviceKeyKey = `${keyPrefix}.deviceKey`;
    const randomPasswordKey = `${keyPrefix}.randomPasswordKey`;
    const deviceGroupKeyKey = `${keyPrefix}.deviceGroupKey`;

//    const storage = window.localStorage;
    const storage = new LocalStorage('/tmp/storage');

    storage.setItem(deviceKeyKey, this.deviceKey);
    storage.setItem(randomPasswordKey, this.randomPassword);
    storage.setItem(deviceGroupKeyKey, this.deviceGroupKey);
  }

});
        if (obj.onopen) {
            obj.onopen();
        }
    });
    ws.on('connectFailed', function(error) {
        console.log('Connect Error: ' + error.toString());
        if (obj.onerror) {
            obj.onerror(error);
        }
    });
    ws.connect(wsurl, protocol);
    return obj;
}
var LocalStorage = require('node-localstorage').LocalStorage;
global.localStorage = new LocalStorage('./persistence');
require('../../lib/mqttws31');

fs.ensureDir(config.baseLocation, (e) => {
      if (e) console.error(e);
      try {
        let test = new LocalStorage(`${config.baseLocation}/system-test`);
        test.clear();
      } catch (e) {
        console.log(e);
        reject(e);
      }
      fs.readdir(config.baseLocation, (err, files) => {
        if (err) console.error(err);
        let c = 0;
        files.forEach(f=> {
          let name = f.split(".")[0];
          tables[name] = new LocalStorage(`${config.baseLocation}/${name}`);
          c++;
        });
        client.funcs.log(`Loaded ${c} tables in ${config.moduleName} database.`);
      });
    });

constructor(path = __dirname) {
    this.store = new LocalStorage(path);
  }

function initializeAPIClient(opts) {
  const hpConf = {
    agent: axios,
    baseUrl: opts.baseUrl || conf.get('baseUrl'),
    store: opts.storage ? opts.storage : new LocalStorage(opts.storagePath),
  };
  return hpFactory(hpConf);
}

case 'win32':
        return `${process.env.APPDATA}\\owo-cli`;
      case 'linux':
        return `${process.env.HOME}/.owo-cli`;
      default:
        return '.';
    }
  }

  const OS_STORAGE_PATH = getOSStoragePath();

  if (!fs.existsSync(OS_STORAGE_PATH)) fs.mkdirSync(OS_STORAGE_PATH);
  const LOCALSTORAGE_PATH = require('path').join(OS_STORAGE_PATH, 'cache');
  if (!fs.existsSync(LOCALSTORAGE_PATH)) fs.mkdirSync(LOCALSTORAGE_PATH);

  return new LocalStorage(LOCALSTORAGE_PATH);
}