add compiled files to repo

mfcodeworks · mfcodeworks · commit a5c6b9c7f5fe · 2020-03-14T15:54:23.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -1,5 +1,4 @@
 # compiled output
-/dist
 /node_modules
 
 # Logs
diff --git a/dist/index.d.ts b/dist/index.d.ts
@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './ipfs.module';
+export * from './ipfs.service';
diff --git a/dist/index.js b/dist/index.js
@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./ipfs.module"));
+__export(require("./ipfs.service"));
diff --git a/dist/interfaces/index.d.ts b/dist/interfaces/index.d.ts
@@ -0,0 +1 @@
+export * from './ipfs-module-options.interface';
diff --git a/dist/interfaces/index.js b/dist/interfaces/index.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/dist/interfaces/ipfs-module-options.interface.d.ts b/dist/interfaces/ipfs-module-options.interface.d.ts
@@ -0,0 +1,39 @@
+import { Type } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+export declare type IPFSModuleOptions = {
+    repo?: string | any;
+    repoAutoMigrate?: boolean;
+    init?: boolean;
+    start?: boolean;
+    pass?: string;
+    silent?: boolean;
+    relay?: IPFSRelayOptions;
+    offline?: boolean;
+    preload?: boolean;
+    EXPERIMENTAL?: IPFSExperimentalOptions;
+    config?: any;
+    ipld?: any;
+    libp2p?: any;
+    connectionManager?: any;
+};
+export interface IPFSModuleOptionsFactory {
+    createIPFSOptions(): Promise<IPFSModuleOptions> | IPFSModuleOptions;
+}
+export interface IPFSModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<IPFSModuleOptionsFactory>;
+    useClass?: Type<IPFSModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<IPFSModuleOptions> | IPFSModuleOptions;
+    inject?: any[];
+    imports?: any[];
+}
+export interface IPFSRelayOptions {
+    enabled: boolean;
+    hop: {
+        enabled: boolean;
+        active: boolean;
+    };
+}
+export interface IPFSExperimentalOptions {
+    ipnsPubsub: boolean;
+    sharding: boolean;
+}
diff --git a/dist/interfaces/ipfs-module-options.interface.js b/dist/interfaces/ipfs-module-options.interface.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/dist/ipfs.constants.d.ts b/dist/ipfs.constants.d.ts
@@ -0,0 +1 @@
+export declare const IPFS_MODULE_OPTIONS = "IPFS_MODULE_OPTIONS";
diff --git a/dist/ipfs.constants.js b/dist/ipfs.constants.js
@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPFS_MODULE_OPTIONS = 'IPFS_MODULE_OPTIONS';
diff --git a/dist/ipfs.module.d.ts b/dist/ipfs.module.d.ts
@@ -0,0 +1,9 @@
+import { DynamicModule } from '@nestjs/common';
+import { IPFSModuleOptions, IPFSModuleAsyncOptions } from './interfaces';
+export declare class IpfsModule {
+    static register(options?: IPFSModuleOptions, waitForNode?: boolean): DynamicModule;
+    static registerAsync(options: IPFSModuleAsyncOptions, waitForNode?: boolean): Promise<DynamicModule>;
+    private static createIPFSService;
+    private static createIPFSProviders;
+    private static createIPFSOptionsProviders;
+}
diff --git a/dist/ipfs.module.js b/dist/ipfs.module.js
@@ -0,0 +1,93 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 IpfsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@nestjs/common");
+const ipfs_constants_1 = require("./ipfs.constants");
+const ipfs_service_1 = require("./ipfs.service");
+let IpfsModule = IpfsModule_1 = class IpfsModule {
+    static register(options = {}, waitForNode = false) {
+        return {
+            module: IpfsModule_1,
+            providers: [
+                {
+                    provide: ipfs_constants_1.IPFS_MODULE_OPTIONS,
+                    useValue: options
+                },
+                ...this.createIPFSService(waitForNode),
+            ],
+            exports: [ipfs_service_1.IpfsService]
+        };
+    }
+    static registerAsync(options, waitForNode = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                module: IpfsModule_1,
+                imports: options.imports || [],
+                providers: [
+                    ...this.createIPFSService(waitForNode),
+                    ...this.createIPFSProviders(options)
+                ],
+                exports: [ipfs_service_1.IpfsService]
+            };
+        });
+    }
+    static createIPFSService(waitForNode) {
+        return waitForNode
+            ? [{
+                    provide: ipfs_service_1.IpfsService,
+                    useFactory: (options) => __awaiter(this, void 0, void 0, function* () {
+                        const service = new ipfs_service_1.IpfsService(options);
+                        yield service.getNode();
+                        return service;
+                    }),
+                    inject: [ipfs_constants_1.IPFS_MODULE_OPTIONS]
+                }]
+            : [ipfs_service_1.IpfsService];
+    }
+    static createIPFSProviders(options) {
+        if (options.useFactory || options.useExisting) {
+            return [this.createIPFSOptionsProviders(options)];
+        }
+        return [
+            this.createIPFSOptionsProviders(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            }
+        ];
+    }
+    static createIPFSOptionsProviders(options) {
+        if (options.useFactory) {
+            return {
+                provide: ipfs_constants_1.IPFS_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || []
+            };
+        }
+        return {
+            provide: ipfs_constants_1.IPFS_MODULE_OPTIONS,
+            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return yield optionsFactory.createIPFSOptions(); }),
+            inject: [options.useExisting] || [options.useClass]
+        };
+    }
+};
+IpfsModule = IpfsModule_1 = __decorate([
+    common_1.Global(),
+    common_1.Module({})
+], IpfsModule);
+exports.IpfsModule = IpfsModule;
diff --git a/dist/ipfs.service.d.ts b/dist/ipfs.service.d.ts
@@ -0,0 +1,9 @@
+import { OnApplicationShutdown } from '@nestjs/common';
+import { IPFSModuleOptions } from './interfaces';
+export declare class IpfsService implements OnApplicationShutdown {
+    private _ipfsOptions;
+    private _ipfsNode;
+    constructor(_ipfsOptions: IPFSModuleOptions);
+    getNode(): Promise<any>;
+    onApplicationShutdown(): Promise<void>;
+}
diff --git a/dist/ipfs.service.js b/dist/ipfs.service.js
@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@nestjs/common");
+const IPFS = require("ipfs");
+const ipfs_constants_1 = require("./ipfs.constants");
+let IpfsService = class IpfsService {
+    constructor(_ipfsOptions) {
+        this._ipfsOptions = _ipfsOptions;
+    }
+    getNode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._ipfsNode
+                ? this._ipfsNode
+                : (this._ipfsNode = yield IPFS.create(this._ipfsOptions));
+        });
+    }
+    onApplicationShutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield this._ipfsNode) && this._ipfsNode.stop();
+        });
+    }
+};
+IpfsService = __decorate([
+    common_1.Injectable(),
+    __param(0, common_1.Inject(ipfs_constants_1.IPFS_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], IpfsService);
+exports.IpfsService = IpfsService;

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`# compiled output`
`2`		`-/dist`
`3`	`2`	`/node_modules`
`4`	`3`
`5`	`4`	`# Logs`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+export * from './interfaces';`
	`2`	`+export * from './ipfs.module';`
	`3`	`+export * from './ipfs.service';`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export * from './ipfs-module-options.interface';`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+"use strict";`
	`2`	`+Object.defineProperty(exports, "__esModule", { value: true });`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export declare const IPFS_MODULE_OPTIONS = "IPFS_MODULE_OPTIONS";`