From 863c235a3152a00fa6f8f8d9780c558e457ef50a Mon Sep 17 00:00:00 2001 From: loynoir Date: Fri, 29 Oct 2021 10:18:21 +0000 Subject: [PATCH 1/2] Add `resolver.resolveAsync` and `multiArgs` --- lib/Resolver.js | 41 ++++++++++++++++++++++++++--- test/multiArgs.js | 66 +++++++++++++++++++++++++++++++++++++++++++++++ types.d.ts | 32 ++++++++++++++++++++++- 3 files changed, 134 insertions(+), 5 deletions(-) create mode 100644 test/multiArgs.js diff --git a/lib/Resolver.js b/lib/Resolver.js index a3120081..27917f1f 100644 --- a/lib/Resolver.js +++ b/lib/Resolver.js @@ -225,17 +225,22 @@ class Resolver { * @param {object} context context information object * @param {string} path context path * @param {string} request request string - * @returns {string | false} result + * @param {ResolveContext} [resolveContext] resolve context + * @param {boolean} [multiArgs] multiArgs + * @returns {string | false | [ string | false, ResolveRequest | undefined]} result */ - resolveSync(context, path, request) { + resolveSync(context, path, request, resolveContext, multiArgs) { /** @type {Error | null | undefined} */ let err = undefined; /** @type {string | false | undefined} */ let result = undefined; + /** @type {ResolveRequest | undefined} */ + let resolveRequest = undefined; let sync = false; - this.resolve(context, path, request, {}, (e, r) => { + this.resolve(context, path, request, resolveContext ?? {}, (e, r, rr) => { err = e; result = r; + resolveRequest = rr; sync = true; }); if (!sync) { @@ -245,7 +250,35 @@ class Resolver { } if (err) throw err; if (result === undefined) throw new Error("No result"); - return result; + if (multiArgs) { + return [result, resolveRequest]; + } else { + return result; + } + } + + /** + * @param {object} context context information object + * @param {string} path context path + * @param {string} request request string + * @param {ResolveContext} [resolveContext] resolve context + * @param {boolean} [multiArgs] multiArgs + * @returns {Promise} + */ + resolveAsync(context, path, request, resolveContext, multiArgs) { + return new Promise((resolve, reject) => { + this.resolve(context, path, request, resolveContext ?? {}, (err, result, resolveRequest) => { + if(err) { + reject(err) + } else if (result === undefined) { + reject(new Error("No result")) + } else if (multiArgs) { + resolve([result, resolveRequest]) + } else { + resolve(result) + } + }) + }) } /** diff --git a/test/multiArgs.js b/test/multiArgs.js new file mode 100644 index 00000000..8ed0c220 --- /dev/null +++ b/test/multiArgs.js @@ -0,0 +1,66 @@ +require("should"); + +var { Volume } = require("memfs"); +var { ResolverFactory } = require("../"); + +describe("multiArgs", function () { + /** + * @type {ReturnType} + */ + var resolver; + + beforeEach(function () { + var fileSystem = Volume.fromJSON( + { + "/a/index": "", + "/a/dir/index": "", + "/recursive/index": "", + "/recursive/dir/index": "", + "/b/index": "", + "/b/dir/index": "", + "/c/index": "", + "/c/dir/index": "", + "/d/index.js": "", + "/d/dir/.empty": "", + "/e/index": "", + "/e/anotherDir/index": "", + "/e/dir/file": "" + }, + "/" + ); + resolver = ResolverFactory.createResolver({ + alias: { + aliasA: "a", + b$: "a/index", + c$: "/a/index", + multiAlias: ["b", "c", "d", "e", "a"], + recursive: "recursive/dir", + "/d/dir": "/c/dir", + "/d/index.js": "/c/index", + ignored: false + }, + modules: "/", + useSyncFileSystemCalls: true, + fileSystem: fileSystem + }); + }); + + it("should resolver.resolveSync parse multiArgs", () => { + resolver.resolveSync({}, "/", "a").should.be.eql("/a/index"); + resolver.resolveSync({}, "/", "a", {}).should.be.eql("/a/index"); + resolver.resolveSync({}, "/", "a", {}, false).should.be.eql("/a/index"); + + Array.isArray(resolver.resolveSync({}, "/", "a", {}, true)).should.be.eql(true); + resolver.resolveSync({}, "/", "a", {}, true)[0].should.be.eql("/a/index"); + resolver.resolveSync({}, "/", "a", {}, true).length.should.be.eql(2); + }); + it("should resolver.resolveAsync parse multiArgs", async () => { + (await resolver.resolveAsync({}, "/", "a")).should.be.eql("/a/index"); + (await resolver.resolveAsync({}, "/", "a", {})).should.be.eql("/a/index"); + (await resolver.resolveAsync({}, "/", "a", {}, false)).should.be.eql("/a/index"); + + Array.isArray((await resolver.resolveAsync({}, "/", "a", {}, true))).should.be.eql(true); + (await resolver.resolveAsync({}, "/", "a", {}, true))[0].should.be.eql("/a/index"); + (await resolver.resolveAsync({}, "/", "a", {}, true)).length.should.be.eql(2); + }); +}); diff --git a/types.d.ts b/types.d.ts index f392bd1c..2397b32e 100644 --- a/types.d.ts +++ b/types.d.ts @@ -280,7 +280,37 @@ declare abstract class Resolver { [ResolveRequest, ResolveContext], null | ResolveRequest >; - resolveSync(context: object, path: string, request: string): string | false; + + resolveSync( + context: object, + path: string, + request: string, + resolveContext?: ResolveContext, + multiArgs?: false + ): string | false; + resolveSync( + context: object, + path: string, + request: string, + resolveContext: ResolveContext, + multiArgs: true + ): [result: string | false, ressolveRequest: ResolveRequest | undefined]; + + resolveAsync( + context: object, + path: string, + request: string, + resolveContext?: ResolveContext, + multiArgs?: false + ): Promise + resolveAsync( + context: object, + path: string, + request: string, + resolveContext: ResolveContext, + multiArgs: true + ): Promise<[result: string | false, ressolveRequest: ResolveRequest | undefined]> + resolve( context: object, path: string, From 9ee8f448d6957a2009002ec3a63f565e934e40ea Mon Sep 17 00:00:00 2001 From: loynoir Date: Fri, 29 Oct 2021 12:40:29 +0000 Subject: [PATCH 2/2] types: add overload --- types.d.ts | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/types.d.ts b/types.d.ts index 2397b32e..04492f5a 100644 --- a/types.d.ts +++ b/types.d.ts @@ -281,6 +281,7 @@ declare abstract class Resolver { null | ResolveRequest >; + //#region resolveSync resolveSync( context: object, path: string, @@ -295,7 +296,16 @@ declare abstract class Resolver { resolveContext: ResolveContext, multiArgs: true ): [result: string | false, ressolveRequest: ResolveRequest | undefined]; + resolveSync( + context: object, + path: string, + request: string, + resolveContext?: ResolveContext, + multiArgs?: boolean + ): string | false | [result: string | false, ressolveRequest: ResolveRequest | undefined]; + //#endregion resolveSync + //#region resolveAsync resolveAsync( context: object, path: string, @@ -310,6 +320,14 @@ declare abstract class Resolver { resolveContext: ResolveContext, multiArgs: true ): Promise<[result: string | false, ressolveRequest: ResolveRequest | undefined]> + resolveAsync( + context: object, + path: string, + request: string, + resolveContext?: ResolveContext, + multiArgs?: boolean + ): Promise + //#endregion resolveAsync resolve( context: object,