@did-space/fs-driver 0.2.5

package/README.md

@@ -0,0 +1 @@
+# DID Spaces Core

package/dist/config/index.d.ts

@@ -0,0 +1,29 @@
+import { SpaceConfigProtocol, SpaceConfig, PermissionOptions } from '@did-space/core';
+export declare class FsSpaceConfig implements SpaceConfigProtocol {
+    private key;
+    constructor({ root }: {
+        root: string;
+    });
+    createConfig(spaceConfig: SpaceConfig): Promise<void>;
+    destroyConfig(): Promise<void>;
+    set<T = any>(key: keyof SpaceConfig, value: T): Promise<void>;
+    get<T = any>(key: keyof SpaceConfig, defaultValue?: T): Promise<T>;
+    private getPermission;
+    /**
+     *
+     * @see https://blog.csdn.net/a1173537204/article/details/89765932
+     * @private
+     * @param {PermissionOptions} { fromAppDid, toAppDid }
+     * @param {number} permission
+     * @param {boolean} status
+     * @return {*}  {Promise<void>}
+     * @memberof FsSpaceConfig
+     */
+    private setPermission;
+    setListable(options: PermissionOptions, status: boolean): Promise<void>;
+    setReadable(options: PermissionOptions, status: boolean): Promise<void>;
+    setWritable(options: PermissionOptions, status: boolean): Promise<void>;
+    isListable(options: PermissionOptions): Promise<boolean>;
+    isReadable(options: PermissionOptions): Promise<boolean>;
+    isWritable(options: PermissionOptions): Promise<boolean>;
+}

package/dist/config/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsSpaceConfig = void 0;
+const path_1 = require("path");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const core_1 = require("@did-space/core");
+class FsSpaceConfig {
+    constructor({ root }) {
+        this.key = (0, path_1.join)(root, 'config.yml');
+    }
+    createConfig(spaceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (fs_extra_1.default.existsSync(this.key)) {
+                throw new Error('The configuration has been initialized and cannot be modified');
+            }
+            const { error } = core_1.SpaceConfigSchema.validate(spaceConfig);
+            if (error) {
+                core_1.logger.error(error);
+                throw error;
+            }
+            // 保存配置在space下的config.yml
+            yield fs_extra_1.default.outputFile(this.key, js_yaml_1.default.dump(spaceConfig));
+        });
+    }
+    destroyConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.remove(this.key);
+        });
+    }
+    // FIXME: @yejianchao 待实现，可以把key对应的Value的类型也带出来？我想到了一种方法，但是我觉得太粗糙了
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = js_yaml_1.default.load((yield fs_extra_1.default.readFile(this.key)).toString());
+            data[key] = value;
+            yield fs_extra_1.default.outputFile(this.key, js_yaml_1.default.dump(data));
+        });
+    }
+    get(key, defaultValue = undefined) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = js_yaml_1.default.load((yield fs_extra_1.default.readFile(this.key)).toString());
+            return (_a = data[key]) !== null && _a !== void 0 ? _a : defaultValue;
+        });
+    }
+    getPermission({ fromAppDid, toAppDid }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const permissions = yield this.get('permissions');
+            return ((_a = permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]) === null || _a === void 0 ? void 0 : _a[toAppDid]) || 0;
+        });
+    }
+    /**
+     *
+     * @see https://blog.csdn.net/a1173537204/article/details/89765932
+     * @private
+     * @param {PermissionOptions} { fromAppDid, toAppDid }
+     * @param {number} permission
+     * @param {boolean} status
+     * @return {*}  {Promise<void>}
+     * @memberof FsSpaceConfig
+     */
+    setPermission({ fromAppDid, toAppDid }, permission, status) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const permissions = yield this.get('permissions', {});
+            // 我想知道原来的权限是啥样的？
+            const oldPermission = ((_a = permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]) === null || _a === void 0 ? void 0 : _a[toAppDid]) || 0;
+            permissions[fromAppDid] = Object.assign((_b = permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]) !== null && _b !== void 0 ? _b : {}, Object.assign(Object.assign({}, permissions === null || permissions === void 0 ? void 0 : permissions[fromAppDid]), { 
+                // eslint-disable-next-line no-bitwise
+                [toAppDid]: status ? oldPermission | permission : oldPermission & ~permission }));
+            yield this.set('permissions', permissions);
+        });
+    }
+    setListable(options, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setPermission(options, core_1.Scopes['list:object'], status);
+        });
+    }
+    setReadable(options, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setPermission(options, core_1.Scopes['read:object'], status);
+        });
+    }
+    setWritable(options, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setPermission(options, core_1.Scopes['write:object'], status);
+        });
+    }
+    isListable(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const permission = yield this.getPermission(options);
+            // eslint-disable-next-line no-bitwise
+            return Boolean((permission & core_1.Scopes['list:object']) === core_1.Scopes['list:object']);
+        });
+    }
+    isReadable(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const permission = yield this.getPermission(options);
+            // eslint-disable-next-line no-bitwise
+            return Boolean((permission & core_1.Scopes['read:object']) === core_1.Scopes['read:object']);
+        });
+    }
+    isWritable(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const permission = yield this.getPermission(options);
+            // eslint-disable-next-line no-bitwise
+            return Boolean((permission & core_1.Scopes['write:object']) === core_1.Scopes['write:object']);
+        });
+    }
+}
+exports.FsSpaceConfig = FsSpaceConfig;

package/dist/fs/index.d.ts

@@ -0,0 +1,8 @@
+import { BaseDriver, DriverOptions, SpaceConfigProtocol, SpaceOperatorProtocol } from '@did-space/core';
+export declare class FsDriver extends BaseDriver {
+    private _spaceConfig;
+    private _spaceOperator;
+    constructor(options: DriverOptions);
+    get spaceOperator(): SpaceOperatorProtocol;
+    get spaceConfig(): SpaceConfigProtocol;
+}

package/dist/fs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsDriver = void 0;
+const core_1 = require("@did-space/core");
+const config_1 = require("../config");
+const operator_1 = require("../operator");
+class FsDriver extends core_1.BaseDriver {
+    constructor(options) {
+        super(options);
+        this._spaceConfig = new config_1.FsSpaceConfig(options);
+        this._spaceOperator = new operator_1.FsSpaceOperator(options);
+    }
+    get spaceOperator() {
+        return this._spaceOperator;
+    }
+    get spaceConfig() {
+        return this._spaceConfig;
+    }
+}
+exports.FsDriver = FsDriver;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './fs';
+export * from './operator';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./fs"), exports);
+__exportStar(require("./operator"), exports);

package/dist/operator/index.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { ReadOptions, WriteOptions, SpaceOperatorProtocol, SpaceConfig, AppSpaceOptions, DeleteOptions, ListOptions, Object, Data, ListsOptions, GetHashOptions } from '@did-space/core';
+import { Stream } from 'stream';
+type PathStatus = {
+    objects: number;
+    lastModified: number;
+    size: number;
+};
+export declare class FsSpaceOperator implements SpaceOperatorProtocol {
+    readonly options: {
+        root: string;
+    };
+    static readonly APPS = "apps";
+    constructor(options: {
+        root: string;
+    });
+    createSpace(_spaceConfig: SpaceConfig): Promise<void>;
+    destroySpace(): Promise<void>;
+    isSpaceCreated(): Promise<boolean>;
+    getSpaceSize(): Promise<number>;
+    getPathStatus(path: string): Promise<PathStatus>;
+    createAppSpace(options: AppSpaceOptions): Promise<void>;
+    destroyAppSpace(options: AppSpaceOptions): Promise<void>;
+    getAppSpacePath(options: AppSpaceOptions): Promise<string>;
+    private getObjectKey;
+    write(options: WriteOptions): Promise<void>;
+    delete(options: DeleteOptions): Promise<void>;
+    read(options: ReadOptions): Promise<Stream>;
+    getHash(options: GetHashOptions): Promise<string>;
+    exists(options: ReadOptions): Promise<boolean>;
+    /**
+     *
+     *
+     * @param {ListsOptions} options
+     * @return {*}  {Promise<Object[]>}
+     * @memberof FsSpaceOperator
+     */
+    lists(options: ListsOptions): Promise<Object[]>;
+    list(options: ListOptions): Promise<Object>;
+    writeAsOwner(key: string, data: Data): Promise<void>;
+    deleteAsOwner(key: string): Promise<void>;
+    readAsOwner(key: string): Promise<Stream>;
+    existsAsOwner(key: string): Promise<boolean>;
+}
+export {};

package/dist/operator/index.js

@@ -0,0 +1,253 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsSpaceOperator = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const core_1 = require("@did-space/core");
+const filehound_1 = __importDefault(require("filehound"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const lodash_1 = require("lodash");
+const mime_types_1 = __importDefault(require("mime-types"));
+const path_1 = require("path");
+const stream_1 = require("stream");
+const hasha_1 = __importDefault(require("hasha"));
+const read_stream_to_file_1 = require("./read-stream-to-file");
+class FsSpaceOperator {
+    constructor(options) {
+        this.options = options;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    createSpace(_spaceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.ensureDir(this.options.root);
+        });
+    }
+    destroySpace() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.remove(this.options.root);
+        });
+    }
+    isSpaceCreated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.existsSync(this.options.root);
+        });
+    }
+    getSpaceSize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathStatus = yield this.getPathStatus(this.options.root);
+            return pathStatus.size;
+        });
+    }
+    getPathStatus(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const files = filehound_1.default.create()
+                .paths(path)
+                .includeFileStats()
+                .findSync();
+            const pathStatus = files.reduce((_pathStatus, file) => {
+                _pathStatus.size += file.stats.size;
+                _pathStatus.objects++;
+                _pathStatus.lastModified = Math.max(new Date(file.stats.mtime).getTime(), _pathStatus.lastModified);
+                return _pathStatus;
+            }, {
+                size: 0,
+                objects: 0,
+                lastModified: 0,
+            });
+            return pathStatus;
+        });
+    }
+    createAppSpace(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.ensureDir(yield this.getAppSpacePath(options));
+        });
+    }
+    destroyAppSpace(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.remove(yield this.getAppSpacePath(options));
+        });
+    }
+    getAppSpacePath(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, path_1.join)(this.options.root, FsSpaceOperator.APPS, options.appDid);
+        });
+    }
+    getObjectKey(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, path_1.join)(yield this.getAppSpacePath(options), options.key);
+        });
+    }
+    write(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objectPath = yield this.getObjectKey(options);
+            const { data } = options;
+            if (objectPath.endsWith('/')) {
+                // 这是一个文件夹
+                yield fs_extra_1.default.ensureDir(objectPath);
+            }
+            else if ((0, lodash_1.isString)(data) || (0, lodash_1.isBuffer)(data)) {
+                yield fs_extra_1.default.outputFile(objectPath, data);
+            }
+            else if (data instanceof stream_1.Stream || data instanceof stream_1.Readable || (0, lodash_1.isFunction)(data === null || data === void 0 ? void 0 : data.pipe)) {
+                fs_extra_1.default.ensureDirSync((0, path_1.dirname)(objectPath));
+                yield (0, read_stream_to_file_1.readStreamToFile)(data, fs_extra_1.default.createWriteStream(objectPath));
+            }
+            else {
+                throw new Error('Data is unsupported format, expected data to be one of: string | Buffer | ReadableStream.');
+            }
+        });
+    }
+    delete(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.remove(yield this.getObjectKey(options));
+        });
+    }
+    read(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objectKey = yield this.getObjectKey(options);
+            return fs_extra_1.default.createReadStream(objectKey);
+        });
+    }
+    getHash(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const streamData = yield this.read(options);
+            const hash = yield hasha_1.default.fromStream(streamData, {
+                algorithm: 'md5',
+            });
+            return hash;
+        });
+    }
+    exists(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.existsSync(yield this.getObjectKey(options));
+        });
+    }
+    /**
+     *
+     *
+     * @param {ListsOptions} options
+     * @return {*}  {Promise<Object[]>}
+     * @memberof FsSpaceOperator
+     */
+    lists(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = (0, path_1.join)(this.options.root, options.key);
+            // 以 非递归的方式 && 显示文件夹 的方式列出当前文件
+            if (!options.recursive) {
+                const objectNames = fs_extra_1.default.readdirSync(path);
+                return Promise.all(objectNames.map((objectName) => __awaiter(this, void 0, void 0, function* () {
+                    const objectKey = (0, path_1.join)(this.options.root, options.key, objectName);
+                    const fileStat = fs_extra_1.default.statSync(objectKey);
+                    const isDir = fileStat.isDirectory();
+                    const directorySuffixes = isDir ? '/' : '';
+                    const key = (0, path_1.join)(options.key, objectName, directorySuffixes);
+                    const name = (0, path_1.join)(objectName, directorySuffixes);
+                    let { size } = fileStat;
+                    let lastModified = new Date(fileStat.mtime).getTime();
+                    if (isDir) {
+                        const pathStatus = yield this.getPathStatus(objectKey);
+                        size = pathStatus.size;
+                        lastModified = pathStatus.lastModified;
+                    }
+                    return {
+                        key,
+                        name,
+                        isDir,
+                        size,
+                        lastModified,
+                        editable: core_1.Space.editable(key),
+                        mimeType: mime_types_1.default.lookup(objectName) || 'unknown',
+                    };
+                })));
+            }
+            if (options.recursive && options.ignoreDirectories) {
+                const files = filehound_1.default.create()
+                    .paths(path)
+                    .includeFileStats()
+                    .findSync();
+                return files.map((file) => {
+                    const key = file.path.replace(path, '');
+                    return {
+                        key,
+                        name: (0, path_1.basename)(key),
+                        isDir: key.endsWith('/'),
+                        size: file.stats.size,
+                        lastModified: new Date(file.stats.mtime).getTime(),
+                        editable: true,
+                        mimeType: mime_types_1.default.lookup((0, path_1.basename)(key)) || 'unknown',
+                    };
+                });
+            }
+            throw new Error(`Filter methods not yet supported:\n ${JSON.stringify(options, null, 2)}`);
+        });
+    }
+    list(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objectKey = (0, path_1.join)(this.options.root, options.key);
+            if (!fs_extra_1.default.existsSync(objectKey)) {
+                return null;
+            }
+            const fileStat = fs_extra_1.default.statSync(objectKey);
+            const objectName = (0, path_1.basename)(objectKey);
+            const directorySuffixes = fileStat.isDirectory() ? '/' : '';
+            const key = (0, path_1.join)(options.key, directorySuffixes);
+            return {
+                key,
+                name: (0, path_1.join)(objectName, directorySuffixes),
+                isDir: fileStat.isDirectory(),
+                size: fileStat.size,
+                lastModified: new Date(fileStat.mtime).getTime(),
+                editable: core_1.Space.editable(key),
+                mimeType: mime_types_1.default.lookup(objectName) || 'unknown',
+            };
+        });
+    }
+    writeAsOwner(key, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const objectPath = (0, path_1.join)(this.options.root, key);
+            if (objectPath.endsWith('/')) {
+                // 这是一个文件夹
+                yield fs_extra_1.default.ensureDir(objectPath);
+            }
+            else if ((0, lodash_1.isString)(data) || (0, lodash_1.isBuffer)(data)) {
+                yield fs_extra_1.default.outputFile(objectPath, data);
+            }
+            else if (data instanceof stream_1.Stream || data instanceof stream_1.Readable || (0, lodash_1.isFunction)(data === null || data === void 0 ? void 0 : data.pipe)) {
+                fs_extra_1.default.ensureDirSync((0, path_1.dirname)(objectPath));
+                yield (0, read_stream_to_file_1.readStreamToFile)(data, fs_extra_1.default.createWriteStream(objectPath));
+            }
+            else {
+                throw new Error('Data is unsupported format, expected data to be one of: string | Buffer | ReadableStream.');
+            }
+        });
+    }
+    deleteAsOwner(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.remove((0, path_1.join)(this.options.root, key));
+        });
+    }
+    readAsOwner(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // FIXME: @yejianchao 应该可以refactor，但是我还需要测试一下
+            return fs_extra_1.default.readFile((0, path_1.join)(this.options.root, key)).then((data) => stream_1.Readable.from(data));
+        });
+    }
+    existsAsOwner(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs_extra_1.default.existsSync((0, path_1.join)(this.options.root, key));
+        });
+    }
+}
+exports.FsSpaceOperator = FsSpaceOperator;
+FsSpaceOperator.APPS = 'apps';

package/dist/operator/read-stream-to-file.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { WriteStream } from 'fs';
+declare function readStreamToFile(readStream: Stream, writeStream: WriteStream): Promise<void>;
+export { readStreamToFile };

package/dist/operator/read-stream-to-file.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStreamToFile = void 0;
+const core_1 = require("@did-space/core");
+function readStreamToFile(readStream, writeStream) {
+    return new Promise((resolve, reject) => {
+        writeStream.on('data', () => {
+            return resolve();
+        });
+        writeStream.on('finish', () => {
+            return resolve();
+        });
+        writeStream.on('error', (error) => {
+            core_1.logger.error('readStreamToFile', error.message);
+            return reject(error);
+        });
+        readStream.pipe(writeStream);
+    });
+}
+exports.readStreamToFile = readStreamToFile;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@did-space/fs-driver",
+  "version": "0.2.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Decentralized file space managed by DID",
+  "author": "linchen1987 <linchen.1987@foxmail.com>",
+  "homepage": "",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "lint": "eslint src tests",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "jest --forceExit --detectOpenHandles --passWithNoTests",
+    "coverage": "yarn test -- --coverage",
+    "prebuild": "rm -fr dist",
+    "build": "tsc",
+    "build:watch": "npm run build -- --watch",
+    "pre-commit": "lint-staged",
+    "verify": "npm run lint && npm run test && npm run build"
+  },
+  "lint-staged": {
+    "**/*.{js,ts}": [
+      "npm run lint",
+      "npm run test",
+      "git add ."
+    ]
+  },
+  "dependencies": {
+    "@arcblock/did": "^1.18.57",
+    "@arcblock/jwt": "^1.18.57",
+    "@did-space/core": "0.2.5",
+    "@ocap/mcrypto": "^1.18.57",
+    "@ocap/wallet": "^1.18.57",
+    "filehound": "^1.17.6",
+    "fs-extra": "^10.1.0",
+    "hasha": "^5.2.2",
+    "js-yaml": "^4.1.0",
+    "json-stable-stringify": "^1.0.1",
+    "lodash": "^4.17.21",
+    "mime-types": "^2.1.35"
+  },
+  "devDependencies": {
+    "@arcblock/eslint-config-ts": "^0.2.3",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jest": "^28.1.5",
+    "@types/js-yaml": "^4.0.5",
+    "@types/json-stable-stringify": "^1.0.34",
+    "@types/lodash": "^4.14.191",
+    "@types/mime-types": "^2.1.1",
+    "@types/node": "15.12.2",
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "eslint": "^8.19.0",
+    "lint-staged": "^13.0.3",
+    "ts-jest": "^28.0.6",
+    "typescript": "^4.9.5"
+  },
+  "gitHead": "4d49e73817f610375982509ba8f250ba34e16efb"
+}