mcp-openapi-schema-explorer 1.0.0

package/test/__tests__/unit/rendering/components.test.ts

@@ -0,0 +1,269 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { RenderableComponents, RenderableComponentMap } from '../../../../src/rendering/components';
+import { RenderContext } from '../../../../src/rendering/types';
+import { IFormatter, JsonFormatter } from '../../../../src/services/formatters';
+
+// Mock Formatter & Context
+const mockFormatter: IFormatter = new JsonFormatter();
+const mockContext: RenderContext = {
+  formatter: mockFormatter,
+  baseUri: 'openapi://',
+};
+
+// Sample Components Object Fixture
+const sampleComponents: OpenAPIV3.ComponentsObject = {
+  schemas: {
+    User: { type: 'object', properties: { name: { type: 'string' } } },
+    Error: { type: 'object', properties: { message: { type: 'string' } } },
+  },
+  parameters: {
+    userIdParam: { name: 'userId', in: 'path', required: true, schema: { type: 'integer' } },
+  },
+  responses: {
+    NotFound: { description: 'Resource not found' },
+  },
+  // Intentionally empty type
+  examples: {},
+  // Intentionally missing type
+  // securitySchemes: {}
+};
+
+const emptyComponents: OpenAPIV3.ComponentsObject = {};
+
+describe('RenderableComponents (List Types)', () => {
+  it('should list available component types correctly', () => {
+    const renderable = new RenderableComponents(sampleComponents);
+    const result = renderable.renderList(mockContext);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].uriSuffix).toBe('components');
+    expect(result[0].renderAsList).toBe(true);
+    expect(result[0].isError).toBeUndefined();
+    expect(result[0].data).toContain('Available Component Types:');
+    // Check sorted types
+    expect(result[0].data).toMatch(/-\s+examples\n/); // Empty but present
+    expect(result[0].data).toMatch(/-\s+parameters\n/);
+    expect(result[0].data).toMatch(/-\s+responses\n/);
+    expect(result[0].data).toMatch(/-\s+schemas\n/);
+    expect(result[0].data).not.toContain('- securitySchemes'); // Missing type
+    expect(result[0].data).toContain("Hint: Use 'openapi://components/{type}'");
+  });
+
+  it('should handle empty components object', () => {
+    const renderable = new RenderableComponents(emptyComponents);
+    const result = renderable.renderList(mockContext);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      uriSuffix: 'components',
+      isError: true, // Changed expectation: should be an error if no components
+      errorText: 'No components found in the specification.',
+      renderAsList: true,
+    });
+  });
+
+  it('should handle components object with no valid types', () => {
+    // Create object with only an extension property but no valid component types
+    const invalidComponents = { 'x-custom': {} } as OpenAPIV3.ComponentsObject;
+    const renderable = new RenderableComponents(invalidComponents);
+    const result = renderable.renderList(mockContext);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      uriSuffix: 'components',
+      isError: true,
+      errorText: 'No valid component types found.',
+      renderAsList: true,
+    });
+  });
+
+  it('should handle undefined components object', () => {
+    const renderable = new RenderableComponents(undefined);
+    const result = renderable.renderList(mockContext);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      uriSuffix: 'components',
+      isError: true,
+      errorText: 'No components found in the specification.',
+      renderAsList: true,
+    });
+  });
+
+  it('renderDetail should delegate to renderList', () => {
+    const renderable = new RenderableComponents(sampleComponents);
+    const listResult = renderable.renderList(mockContext);
+    const detailResult = renderable.renderDetail(mockContext);
+    expect(detailResult).toEqual(listResult);
+  });
+
+  it('getComponentMap should return correct map', () => {
+    const renderable = new RenderableComponents(sampleComponents);
+    expect(renderable.getComponentMap('schemas')).toBe(sampleComponents.schemas);
+    expect(renderable.getComponentMap('parameters')).toBe(sampleComponents.parameters);
+    expect(renderable.getComponentMap('examples')).toBe(sampleComponents.examples);
+    expect(renderable.getComponentMap('securitySchemes')).toBeUndefined();
+  });
+});
+
+describe('RenderableComponentMap (List/Detail Names)', () => {
+  const schemasMap = sampleComponents.schemas;
+  const parametersMap = sampleComponents.parameters;
+  const emptyMap = sampleComponents.examples;
+  const schemasUriSuffix = 'components/schemas';
+  const paramsUriSuffix = 'components/parameters';
+
+  describe('renderList (List Names)', () => {
+    it('should list component names correctly (schemas)', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      const result = renderable.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0].uriSuffix).toBe(schemasUriSuffix);
+      expect(result[0].renderAsList).toBe(true);
+      expect(result[0].isError).toBeUndefined();
+      expect(result[0].data).toContain('Available schemas:');
+      expect(result[0].data).toMatch(/-\s+Error\n/); // Sorted
+      expect(result[0].data).toMatch(/-\s+User\n/);
+      expect(result[0].data).toContain("Hint: Use 'openapi://components/schemas/{name}'");
+    });
+
+    it('should list component names correctly (parameters)', () => {
+      const renderable = new RenderableComponentMap(parametersMap, 'parameters', paramsUriSuffix);
+      const result = renderable.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0].uriSuffix).toBe(paramsUriSuffix);
+      expect(result[0].data).toContain('Available parameters:');
+      expect(result[0].data).toMatch(/-\s+userIdParam\n/);
+      expect(result[0].data).toContain("Hint: Use 'openapi://components/parameters/{name}'");
+    });
+
+    it('should handle empty component map', () => {
+      const renderable = new RenderableComponentMap(emptyMap, 'examples', 'components/examples');
+      const result = renderable.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        uriSuffix: 'components/examples',
+        isError: true,
+        errorText: 'No components of type "examples" found.',
+        renderAsList: true,
+      });
+    });
+
+    it('should handle undefined component map', () => {
+      const renderable = new RenderableComponentMap(
+        undefined,
+        'securitySchemes',
+        'components/securitySchemes'
+      );
+      const result = renderable.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        uriSuffix: 'components/securitySchemes',
+        isError: true,
+        errorText: 'No components of type "securitySchemes" found.',
+        renderAsList: true,
+      });
+    });
+  });
+
+  describe('renderComponentDetail (Get Component Detail)', () => {
+    it('should return detail for a single valid component', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      const result = renderable.renderComponentDetail(mockContext, ['User']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: `${schemasUriSuffix}/User`,
+        data: schemasMap?.User, // Expect raw component object
+      });
+    });
+
+    it('should return details for multiple valid components', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      const result = renderable.renderComponentDetail(mockContext, ['Error', 'User']);
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual({
+        uriSuffix: `${schemasUriSuffix}/Error`,
+        data: schemasMap?.Error,
+      });
+      expect(result).toContainEqual({
+        uriSuffix: `${schemasUriSuffix}/User`,
+        data: schemasMap?.User,
+      });
+    });
+
+    it('should return error for non-existent component', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      const result = renderable.renderComponentDetail(mockContext, ['NonExistent']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: `${schemasUriSuffix}/NonExistent`,
+        data: null,
+        isError: true,
+        errorText: 'Component "NonExistent" of type "schemas" not found.',
+        renderAsList: true,
+      });
+    });
+
+    it('should handle mix of valid and invalid components', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      const result = renderable.renderComponentDetail(mockContext, ['User', 'Invalid']);
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual({
+        uriSuffix: `${schemasUriSuffix}/User`,
+        data: schemasMap?.User,
+      });
+      expect(result).toContainEqual({
+        uriSuffix: `${schemasUriSuffix}/Invalid`,
+        data: null,
+        isError: true,
+        errorText: 'Component "Invalid" of type "schemas" not found.',
+        renderAsList: true,
+      });
+    });
+
+    it('should return error if component map is undefined', () => {
+      const renderable = new RenderableComponentMap(
+        undefined,
+        'securitySchemes',
+        'components/securitySchemes'
+      );
+      const result = renderable.renderComponentDetail(mockContext, ['apiKey']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: 'components/securitySchemes/apiKey',
+        data: null,
+        isError: true,
+        errorText: 'Component map for type "securitySchemes" not found.',
+        renderAsList: true,
+      });
+    });
+  });
+
+  describe('renderDetail (Interface Method)', () => {
+    it('should delegate to renderList', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      const listResult = renderable.renderList(mockContext);
+      const detailResult = renderable.renderDetail(mockContext);
+      expect(detailResult).toEqual(listResult);
+    });
+  });
+
+  describe('getComponent', () => {
+    it('should return correct component object', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      expect(renderable.getComponent('User')).toBe(schemasMap?.User);
+      expect(renderable.getComponent('Error')).toBe(schemasMap?.Error);
+    });
+
+    it('should return undefined for non-existent component', () => {
+      const renderable = new RenderableComponentMap(schemasMap, 'schemas', schemasUriSuffix);
+      expect(renderable.getComponent('NonExistent')).toBeUndefined();
+    });
+
+    it('should return undefined if component map is undefined', () => {
+      const renderable = new RenderableComponentMap(
+        undefined,
+        'securitySchemes',
+        'components/securitySchemes'
+      );
+      expect(renderable.getComponent('apiKey')).toBeUndefined();
+    });
+  });
+});

package/test/__tests__/unit/rendering/document.test.ts

@@ -0,0 +1,172 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { RenderableDocument } from '../../../../src/rendering/document';
+import { RenderContext } from '../../../../src/rendering/types';
+import { IFormatter, JsonFormatter } from '../../../../src/services/formatters';
+
+// Mock Formatter
+const mockFormatter: IFormatter = new JsonFormatter(); // Use JSON for predictable output
+
+const mockContext: RenderContext = {
+  formatter: mockFormatter,
+  baseUri: 'openapi://',
+};
+
+// Sample OpenAPI Document Fixture
+const sampleDoc: OpenAPIV3.Document = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Test API',
+    version: '1.0.0',
+  },
+  paths: {
+    '/test': {
+      get: {
+        summary: 'Test GET',
+        responses: {
+          '200': { description: 'OK' },
+        },
+      },
+    },
+  },
+  components: {
+    schemas: {
+      TestSchema: { type: 'string' },
+    },
+  },
+  servers: [{ url: 'http://localhost:3000' }],
+};
+
+describe('RenderableDocument', () => {
+  let renderableDoc: RenderableDocument;
+
+  beforeEach(() => {
+    renderableDoc = new RenderableDocument(sampleDoc);
+  });
+
+  it('should instantiate correctly', () => {
+    expect(renderableDoc).toBeInstanceOf(RenderableDocument);
+  });
+
+  // Test the internal detail rendering method
+  describe('renderTopLevelFieldDetail', () => {
+    it('should render detail for a valid top-level field (info)', () => {
+      const fieldObject = renderableDoc.getTopLevelField('info');
+      const result = renderableDoc.renderTopLevelFieldDetail(mockContext, fieldObject, 'info');
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: 'info',
+        data: sampleDoc.info, // Expect raw data
+        isError: undefined, // Should default to false implicitly
+        renderAsList: undefined, // Should default to false implicitly
+      });
+    });
+
+    it('should render detail for another valid field (servers)', () => {
+      const fieldObject = renderableDoc.getTopLevelField('servers');
+      const result = renderableDoc.renderTopLevelFieldDetail(mockContext, fieldObject, 'servers');
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: 'servers',
+        data: sampleDoc.servers,
+        isError: undefined,
+        renderAsList: undefined,
+      });
+    });
+
+    it('should return error for non-existent field', () => {
+      const fieldObject = renderableDoc.getTopLevelField('nonexistent');
+      const result = renderableDoc.renderTopLevelFieldDetail(
+        mockContext,
+        fieldObject, // Will be undefined
+        'nonexistent'
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: 'nonexistent',
+        data: null,
+        isError: true,
+        errorText: 'Error: Field "nonexistent" not found in the OpenAPI document.',
+        renderAsList: true,
+      });
+    });
+
+    it('should return error when trying to render "paths" via detail method', () => {
+      const fieldObject = renderableDoc.getTopLevelField('paths');
+      const result = renderableDoc.renderTopLevelFieldDetail(mockContext, fieldObject, 'paths');
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: 'paths',
+        data: null,
+        isError: true,
+        errorText: `Error: Field "paths" should be accessed via its list view (${mockContext.baseUri}paths). Use the list view first.`,
+        renderAsList: true,
+      });
+    });
+
+    it('should return error when trying to render "components" via detail method', () => {
+      const fieldObject = renderableDoc.getTopLevelField('components');
+      const result = renderableDoc.renderTopLevelFieldDetail(
+        mockContext,
+        fieldObject,
+        'components'
+      );
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: 'components',
+        data: null,
+        isError: true,
+        errorText: `Error: Field "components" should be accessed via its list view (${mockContext.baseUri}components). Use the list view first.`,
+        renderAsList: true,
+      });
+    });
+  });
+
+  // Test the interface methods (which currently return errors)
+  describe('Interface Methods', () => {
+    it('renderList should return error', () => {
+      const result = renderableDoc.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        uriSuffix: 'error',
+        isError: true,
+        errorText: expect.stringContaining(
+          'List rendering is only supported for specific fields'
+        ) as string,
+        renderAsList: true,
+      });
+    });
+
+    it('renderDetail should return error', () => {
+      const result = renderableDoc.renderDetail(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        uriSuffix: 'error',
+        isError: true,
+        errorText: expect.stringContaining(
+          'Detail rendering requires specifying a top-level field'
+        ) as string,
+        renderAsList: true,
+      });
+    });
+  });
+
+  // Test helper methods
+  describe('Helper Methods', () => {
+    it('getPathsObject should return paths', () => {
+      expect(renderableDoc.getPathsObject()).toBe(sampleDoc.paths);
+    });
+    it('getComponentsObject should return components', () => {
+      expect(renderableDoc.getComponentsObject()).toBe(sampleDoc.components);
+    });
+    it('getTopLevelField should return correct field', () => {
+      expect(renderableDoc.getTopLevelField('info')).toBe(sampleDoc.info);
+      expect(renderableDoc.getTopLevelField('servers')).toBe(sampleDoc.servers);
+      expect(renderableDoc.getTopLevelField('nonexistent')).toBeUndefined();
+    });
+  });
+});

package/test/__tests__/unit/rendering/path-item.test.ts

@@ -0,0 +1,197 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { RenderablePathItem } from '../../../../src/rendering/path-item';
+import { RenderContext } from '../../../../src/rendering/types';
+import { IFormatter, JsonFormatter } from '../../../../src/services/formatters';
+
+// Mock Formatter & Context
+const mockFormatter: IFormatter = new JsonFormatter();
+const mockContext: RenderContext = {
+  formatter: mockFormatter,
+  baseUri: 'openapi://',
+};
+
+// Sample PathItem Object Fixture
+const samplePathItem: OpenAPIV3.PathItemObject = {
+  get: {
+    summary: 'Get Item',
+    responses: { '200': { description: 'OK' } },
+  },
+  post: {
+    summary: 'Create Item',
+    responses: { '201': { description: 'Created' } },
+  },
+  delete: {
+    // No summary
+    responses: { '204': { description: 'No Content' } },
+  },
+  parameters: [
+    // Example path-level parameter
+    { name: 'commonParam', in: 'query', schema: { type: 'string' } },
+  ],
+};
+
+// Define both the raw path and the expected suffix (built using the builder logic)
+const rawPath = '/items';
+const pathUriSuffix = 'paths/items'; // Builder removes leading '/' and encodes, but '/items' has no special chars
+
+describe('RenderablePathItem', () => {
+  describe('renderList (List Methods)', () => {
+    it('should render a list of methods correctly', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      const result = renderable.renderList(mockContext);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].uriSuffix).toBe(pathUriSuffix);
+      expect(result[0].renderAsList).toBe(true);
+      expect(result[0].isError).toBeUndefined();
+
+      // Define expected output lines based on the new format and builder logic
+      // generateListHint uses buildOperationUriSuffix which encodes the path
+      // Since rawPath is '/items', encoded is 'items'.
+      const expectedHint =
+        "Hint: Use 'openapi://paths/items/{method}' to view details for a specific operation.";
+      const expectedLineDelete = 'DELETE'; // No summary/opId
+      const expectedLineGet = 'GET: Get Item'; // Summary exists
+      const expectedLinePost = 'POST: Create Item'; // Summary exists
+      const expectedOutput = `${expectedHint}\n\n${expectedLineDelete}\n${expectedLineGet}\n${expectedLinePost}`;
+
+      // Check the full output string
+      expect(result[0].data).toBe(expectedOutput);
+    });
+
+    it('should handle path item with no standard methods', () => {
+      const noMethodsPathItem: OpenAPIV3.PathItemObject = {
+        parameters: samplePathItem.parameters,
+      };
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(noMethodsPathItem, rawPath, pathUriSuffix);
+      const result = renderable.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: pathUriSuffix,
+        data: 'No standard HTTP methods found for path: items',
+        renderAsList: true,
+      });
+    });
+
+    it('should return error if path item is undefined', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(undefined, rawPath, pathUriSuffix);
+      const result = renderable.renderList(mockContext);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        uriSuffix: pathUriSuffix,
+        isError: true,
+        errorText: 'Path item not found.',
+        renderAsList: true,
+      });
+    });
+  });
+
+  describe('renderOperationDetail (Get Operation Detail)', () => {
+    it('should return detail for a single valid method', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      const result = renderable.renderOperationDetail(mockContext, ['get']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: `${pathUriSuffix}/get`,
+        data: samplePathItem.get, // Expect raw operation object
+      });
+    });
+
+    it('should return details for multiple valid methods', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      const result = renderable.renderOperationDetail(mockContext, ['post', 'delete']);
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual({
+        uriSuffix: `${pathUriSuffix}/post`,
+        data: samplePathItem.post,
+      });
+      expect(result).toContainEqual({
+        uriSuffix: `${pathUriSuffix}/delete`,
+        data: samplePathItem.delete,
+      });
+    });
+
+    it('should return error for non-existent method', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      const result = renderable.renderOperationDetail(mockContext, ['put']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: `${pathUriSuffix}/put`,
+        data: null,
+        isError: true,
+        errorText: 'Method "PUT" not found for path.',
+        renderAsList: true,
+      });
+    });
+
+    it('should handle mix of valid and invalid methods', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      const result = renderable.renderOperationDetail(mockContext, ['get', 'patch']);
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual({
+        uriSuffix: `${pathUriSuffix}/get`,
+        data: samplePathItem.get,
+      });
+      expect(result).toContainEqual({
+        uriSuffix: `${pathUriSuffix}/patch`,
+        data: null,
+        isError: true,
+        errorText: 'Method "PATCH" not found for path.',
+        renderAsList: true,
+      });
+    });
+
+    it('should return error if path item is undefined', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(undefined, rawPath, pathUriSuffix);
+      const result = renderable.renderOperationDetail(mockContext, ['get']);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        uriSuffix: `${pathUriSuffix}/get`,
+        data: null,
+        isError: true,
+        errorText: 'Path item not found.',
+        renderAsList: true,
+      });
+    });
+  });
+
+  describe('renderDetail (Interface Method)', () => {
+    it('should delegate to renderList', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      const listResult = renderable.renderList(mockContext);
+      const detailResult = renderable.renderDetail(mockContext);
+      expect(detailResult).toEqual(listResult);
+    });
+  });
+
+  describe('getOperation', () => {
+    it('should return correct operation object (case-insensitive)', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      expect(renderable.getOperation('get')).toBe(samplePathItem.get);
+      expect(renderable.getOperation('POST')).toBe(samplePathItem.post);
+      expect(renderable.getOperation('Delete')).toBe(samplePathItem.delete);
+    });
+
+    it('should return undefined for non-existent method', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(samplePathItem, rawPath, pathUriSuffix);
+      expect(renderable.getOperation('put')).toBeUndefined();
+    });
+
+    it('should return undefined if path item is undefined', () => {
+      // Provide all 3 arguments to constructor
+      const renderable = new RenderablePathItem(undefined, rawPath, pathUriSuffix);
+      expect(renderable.getOperation('get')).toBeUndefined();
+    });
+  });
+});