refactor: resolver option renamed to nameResolver

README.md

@@ -380,8 +380,8 @@ console.log(result);
 ```js
 import {projectData} from '@e22m4u/js-data-projection';
 
-// функция для разрешения имен
-const resolver = name => {
+// функция разрешения имен
+const nameResolver = name => {
   if (name === 'user') {
     return {id: true, name: true, password: false};
   }
@@ -397,7 +397,7 @@ const data = {
 const result = projectData(
   'user', // <= вместо схемы передается имя
   data,
-  {resolver}, // <= разрешающая функция
+  {nameResolver}, // <= разрешающая функция
 );
 console.log(result);
 // {

dist/cjs/index.cjs

@@ -144,10 +144,10 @@ function projectData(schema, data, options) {
         options.scope
       );
     }
-    if (options.resolver !== void 0 && typeof options.resolver !== "function") {
+    if (options.nameResolver !== void 0 && typeof options.nameResolver !== "function") {
       throw new import_js_format2.InvalidArgumentError(
-        'Projection option "resolver" must be a Function, but %v was given.',
-        options.resolver
+        'Projection option "nameResolver" must be a Function, but %v was given.',
+        options.nameResolver
       );
     }
     if (options.factoryArgs !== void 0 && !Array.isArray(options.factoryArgs)) {
@@ -168,16 +168,16 @@ function projectData(schema, data, options) {
     }
   }
   if (typeof schema === "string") {
-    if (!options || !options.resolver) {
+    if (!options || !options.nameResolver) {
       throw new import_js_format2.InvalidArgumentError(
-        'Projection option "resolver" is required to resolve %v schema.',
+        'Projection option "nameResolver" is required to resolve %v name.',
         schema
       );
     }
-    schema = options.resolver(schema);
+    schema = options.nameResolver(schema);
     if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
       throw new import_js_format2.InvalidArgumentError(
-        "Schema resolver must return an Object, but %v was given.",
+        "Name resolver must return an Object, but %v was given.",
         schema
       );
     }
@@ -352,10 +352,10 @@ var _DataProjector = class _DataProjector extends import_js_service2.Service {
    */
   project(schema, data, options) {
     const registry = this.getService(ProjectionSchemaRegistry);
-    const defaultResolver = /* @__PURE__ */ __name((name) => registry.getSchema(name), "defaultResolver");
-    const resolver = options && options.resolver || defaultResolver;
+    const defaultNameResolver = /* @__PURE__ */ __name((name) => registry.getSchema(name), "defaultNameResolver");
+    const nameResolver = options && options.nameResolver || defaultNameResolver;
     const factoryArgs = options && options.factoryArgs || [this.container];
-    return projectData(schema, data, { ...options, resolver, factoryArgs });
+    return projectData(schema, data, { ...options, nameResolver, factoryArgs });
   }
 };
 __name(_DataProjector, "DataProjector");

src/data-projector.js

@@ -27,9 +27,10 @@ export class DataProjector extends Service {
    */
   project(schema, data, options) {
     const registry = this.getService(ProjectionSchemaRegistry);
-    const defaultResolver = name => registry.getSchema(name);
-    const resolver = (options && options.resolver) || defaultResolver;
+    const defaultNameResolver = name => registry.getSchema(name);
+    const nameResolver =
+      (options && options.nameResolver) || defaultNameResolver;
     const factoryArgs = (options && options.factoryArgs) || [this.container];
-    return projectData(schema, data, {...options, resolver, factoryArgs});
+    return projectData(schema, data, {...options, nameResolver, factoryArgs});
   }
 }

src/data-projector.spec.js

@@ -64,16 +64,16 @@ describe('DataProjector', function () {
       expect(res).to.be.eql({foo: 10});
     });
 
-    it('should allow override the "resolver" option', function () {
+    it('should allow override the "nameResolver" option', function () {
       const S = new DataProjector();
       const schemaName = 'mySchema';
       let invoked = 0;
-      const resolver = name => {
+      const nameResolver = name => {
         invoked++;
         expect(name).to.be.eq(schemaName);
         return {foo: true, bar: false};
       };
-      const res = S.project('mySchema', {foo: 10, bar: 20}, {resolver});
+      const res = S.project('mySchema', {foo: 10, bar: 20}, {nameResolver});
       expect(res).to.be.eql({foo: 10});
       expect(invoked).to.be.eq(1);
     });

src/project-data.js

@@ -36,15 +36,15 @@ export function projectData(schema, data, options) {
         options.scope,
       );
     }
-    // options.resolver
+    // options.nameResolver
     if (
-      options.resolver !== undefined &&
-      typeof options.resolver !== 'function'
+      options.nameResolver !== undefined &&
+      typeof options.nameResolver !== 'function'
     ) {
       throw new InvalidArgumentError(
-        'Projection option "resolver" must be a Function, ' +
+        'Projection option "nameResolver" must be a Function, ' +
           'but %v was given.',
-        options.resolver,
+        options.nameResolver,
       );
     }
     // options.factoryArgs
@@ -81,18 +81,18 @@ export function projectData(schema, data, options) {
   if (typeof schema === 'string') {
     // если разрешающая функция не определена,
     // то выбрасывается ошибка
-    if (!options || !options.resolver) {
+    if (!options || !options.nameResolver) {
       throw new InvalidArgumentError(
-        'Projection option "resolver" is required to resolve %v schema.',
+        'Projection option "nameResolver" is required to resolve %v name.',
         schema,
       );
     }
-    schema = options.resolver(schema);
+    schema = options.nameResolver(schema);
     // если результат разрешающей функции не является
     // объектом, то выбрасывается ошибка
     if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
       throw new InvalidArgumentError(
-        'Schema resolver must return an Object, but %v was given.',
+        'Name resolver must return an Object, but %v was given.',
         schema,
       );
     }

src/project-data.spec.js

@@ -58,11 +58,12 @@ describe('projectData', function () {
     throwable(undefined)();
   });
 
-  it('should require the "resolver" option to be a function', function () {
-    const throwable = v => () => projectData({}, 10, {resolver: v});
+  it('should require the "nameResolver" option to be a function', function () {
+    const throwable = v => () => projectData({}, 10, {nameResolver: v});
     const error = s =>
       format(
-        'Projection option "resolver" must be a Function, but %s was given.',
+        'Projection option "nameResolver" must be ' +
+          'a Function, but %s was given.',
         s,
       );
     expect(throwable('str')).to.throw(error('"str"'));
@@ -139,33 +140,34 @@ describe('projectData', function () {
     expect(throwable(null)).to.throw(error('null'));
     expect(throwable(() => undefined)).to.throw(error('Function'));
     projectData(() => ({}), {});
-    projectData(() => 'str', {}, {resolver: () => ({})});
+    projectData(() => 'str', {}, {nameResolver: () => ({})});
   });
 
-  it('should resolve the schema name by the given resolver', function () {
+  it('should resolve the schema name by the name resolver', function () {
     let invoked = 0;
-    const resolver = name => {
+    const nameResolver = name => {
       invoked++;
       expect(name).to.be.eql('mySchema');
       return {foo: true, bar: false};
     };
-    const res = projectData('mySchema', {foo: 10, bar: 20}, {resolver});
+    const res = projectData('mySchema', {foo: 10, bar: 20}, {nameResolver});
     expect(res).to.be.eql({foo: 10});
     expect(invoked).to.be.eq(1);
   });
 
-  it('should require the "resolver" option when the schema name is provided', function () {
+  it('should require the "nameResolver" option when the schema name is provided', function () {
     const throwable = () => projectData('mySchema', {});
     expect(throwable).to.throw(
-      'Projection option "resolver" is required to resolve "mySchema" schema.',
+      'Projection option "nameResolver" is required ' +
+        'to resolve "mySchema" name.',
     );
   });
 
-  it('should require a resolver result to be an object', function () {
+  it('should require the name resolver to return an object', function () {
     const throwable = v => () =>
-      projectData('mySchema', {}, {resolver: () => v});
+      projectData('mySchema', {}, {nameResolver: () => v});
     const error = s =>
-      format('Schema resolver must return an Object, but %s was given.', s);
+      format('Name resolver must return an Object, but %s was given.', s);
     expect(throwable('str')).to.throw(error('"str"'));
     expect(throwable('')).to.throw(error('""'));
     expect(throwable(10)).to.throw(error('10'));
@@ -181,19 +183,23 @@ describe('projectData', function () {
 
   it('should resolve the schema name from the factory function', function () {
     let invoked = 0;
-    const resolver = name => {
+    const nameResolver = name => {
       invoked++;
       expect(name).to.be.eql('mySchema');
       return {foo: true, bar: false};
     };
-    const res = projectData(() => 'mySchema', {foo: 10, bar: 20}, {resolver});
+    const res = projectData(
+      () => 'mySchema',
+      {foo: 10, bar: 20},
+      {nameResolver},
+    );
     expect(res).to.be.eql({foo: 10});
     expect(invoked).to.be.eq(1);
   });
 
-  it('should resolve the named schema in the the nested object', function () {
+  it('should resolve the schema name in the the nested object', function () {
     let invoked = 0;
-    const resolver = name => {
+    const nameResolver = name => {
       invoked++;
       if (name === 'schema1') {
         return {foo: true, bar: {schema: 'schema2'}};
@@ -202,7 +208,7 @@ describe('projectData', function () {
       }
     };
     const data = {foo: 10, bar: {baz: 20, qux: 30}};
-    const res = projectData('schema1', data, {resolver});
+    const res = projectData('schema1', data, {nameResolver});
     expect(res).to.be.eql({foo: 10, bar: {baz: 20}});
     expect(invoked).to.be.eq(2);
   });