@openedx/paragon 23.5.1 → 23.6.0

package/lib/__tests__/build-scss.test.js

@@ -0,0 +1,146 @@
+const fs = require('fs');
+const sass = require('sass');
+
+const buildScssCommand = require('../build-scss');
+const { updateParagonThemeOutput } = require('../build-scss');
+
+jest.mock('fs');
+jest.mock('sass');
+jest.mock('postcss', () => jest.fn().mockReturnValue({
+  process: jest.fn().mockResolvedValue({
+    css: '.processed { color: black; }',
+    map: {
+      toString: () => 'minified sourcemap content',
+    },
+  }),
+}));
+jest.mock('ora', () => jest.fn(() => ({
+  start: jest.fn().mockReturnThis(),
+  succeed: jest.fn().mockReturnThis(),
+  fail: jest.fn().mockReturnThis(),
+})));
+
+describe('updateParagonThemeOutput', () => {
+  it('should add core theme correctly', () => {
+    const input = {
+      paragonThemeOutput: { themeUrls: {} },
+      name: 'core',
+      isThemeVariant: false,
+      isDefaultThemeVariant: false,
+    };
+
+    const expected = {
+      themeUrls: {
+        core: {
+          paths: {
+            default: './core.css',
+            minified: './core.min.css',
+          },
+        },
+      },
+    };
+
+    const result = updateParagonThemeOutput(input);
+    expect(result).toEqual(expected);
+  });
+
+  it('should add theme variant correctly', () => {
+    const input = {
+      paragonThemeOutput: { themeUrls: {} },
+      name: 'light',
+      isThemeVariant: true,
+      isDefaultThemeVariant: false,
+    };
+
+    const expected = {
+      themeUrls: {
+        variants: {
+          light: {
+            paths: {
+              default: './light.css',
+              minified: './light.min.css',
+            },
+          },
+        },
+      },
+    };
+
+    const result = updateParagonThemeOutput(input);
+    expect(result).toEqual(expected);
+  });
+
+  it('should add default theme variant correctly', () => {
+    const input = {
+      paragonThemeOutput: { themeUrls: {} },
+      name: 'light',
+      isThemeVariant: true,
+      isDefaultThemeVariant: true,
+    };
+
+    const expected = {
+      themeUrls: {
+        defaults: {
+          light: 'light',
+        },
+        variants: {
+          light: {
+            paths: {
+              default: './light.css',
+              minified: './light.min.css',
+            },
+          },
+        },
+      },
+    };
+
+    const result = updateParagonThemeOutput(input);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('buildScssCommand', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    fs.readdirSync.mockReturnValue([
+      { name: 'light', isDirectory: () => true },
+      { name: 'dark', isDirectory: () => true },
+    ]);
+    sass.compile.mockReturnValue({
+      css: '.test { color: black; }',
+      map: {
+        toString: () => 'sourcemap content',
+      },
+    });
+  });
+
+  it('should compile core and theme stylesheets', () => {
+    const args = [
+      '--corePath=styles/core.scss',
+      '--themesPath=styles/themes',
+      '--outDir=dist',
+      '--defaultThemeVariants=light',
+    ];
+
+    buildScssCommand(args);
+
+    expect(sass.compile).toHaveBeenCalledWith(
+      expect.stringContaining('core.scss'),
+      expect.any(Object),
+    );
+
+    expect(fs.readdirSync).toHaveBeenCalledWith(
+      expect.stringContaining('themes'),
+      expect.objectContaining({ withFileTypes: true }),
+    );
+  });
+
+  it('should use default arguments when none provided', () => {
+    buildScssCommand([]);
+
+    expect(sass.compile).toHaveBeenCalledWith(
+      expect.stringContaining('core.scss'),
+      expect.any(Object),
+    );
+  });
+});

package/lib/__tests__/build-tokens.test.js

@@ -0,0 +1,106 @@
+const buildTokensCommand = require('../build-tokens');
+const {
+  initializeStyleDictionary,
+  __mockClass: StyleDictionary,
+  __mockInstance: styleDictionaryInstance,
+} = require('../../tokens/style-dictionary');
+const { createIndexCssFile } = require('../../tokens/utils');
+
+jest.mock('../../tokens/style-dictionary');
+jest.mock('../../tokens/utils');
+
+describe('buildTokensCommand', () => {
+  const defaultBuildDir = './build/';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should use default parameters when no arguments provided', async () => {
+    await buildTokensCommand([]);
+
+    expect(initializeStyleDictionary).toHaveBeenCalledWith(
+      expect.objectContaining({
+        themes: ['light'],
+      }),
+    );
+  });
+
+  it('should handle multiple themes correctly', async () => {
+    await buildTokensCommand(['--themes', 'light,dark']);
+
+    expect(StyleDictionary).toHaveBeenCalledTimes(3); // 1 for core + 2 for themes
+    expect(createIndexCssFile).toHaveBeenCalledTimes(3);
+
+    // Verify index files creation for core and each theme
+    const expectedCalls = [
+      { isThemeVariant: false, themeVariant: undefined },
+      { isThemeVariant: true, themeVariant: 'light' },
+      { isThemeVariant: true, themeVariant: 'dark' },
+    ];
+
+    expectedCalls.forEach(params => {
+      expect(createIndexCssFile).toHaveBeenCalledWith(expect.objectContaining({
+        buildDir: defaultBuildDir,
+        ...params,
+      }));
+    });
+  });
+
+  it('should handle source-tokens-only flag', async () => {
+    await buildTokensCommand(['--source-tokens-only']);
+
+    expect(StyleDictionary).toHaveBeenCalledWith(expect.objectContaining({
+      platforms: expect.objectContaining({
+        css: expect.objectContaining({
+          files: expect.arrayContaining([
+            expect.objectContaining({
+              filter: 'isSource',
+            }),
+          ]),
+        }),
+      }),
+    }));
+  });
+
+  it('should use custom build path', async () => {
+    const customBuildDir = './custom-build/';
+    await buildTokensCommand(['--build-dir', customBuildDir]);
+
+    expect(StyleDictionary).toHaveBeenCalledWith(expect.objectContaining({
+      platforms: expect.objectContaining({
+        css: expect.objectContaining({
+          buildPath: customBuildDir,
+        }),
+      }),
+    }));
+  });
+
+  it('should handle custom token source', async () => {
+    const customSource = './custom-tokens';
+    await buildTokensCommand(['--source', customSource]);
+
+    expect(StyleDictionary).toHaveBeenCalledWith(expect.objectContaining({
+      source: expect.arrayContaining([
+        expect.stringContaining(customSource),
+      ]),
+    }));
+  });
+
+  it('should handle build errors', async () => {
+    const errorMessage = 'Clean error';
+    styleDictionaryInstance.cleanAllPlatforms.mockRejectedValueOnce(new Error(errorMessage));
+
+    await expect(buildTokensCommand([])).rejects.toThrow(errorMessage);
+  });
+
+  it('should handle verbose flag', async () => {
+    await buildTokensCommand(['--verbose']);
+
+    expect(StyleDictionary).toHaveBeenCalledWith(expect.objectContaining({
+      log: {
+        verbosity: 'verbose',
+      },
+    }));
+  });
+});

package/lib/__tests__/help.test.js

@@ -0,0 +1,301 @@
+const chalk = require('chalk');
+
+const { COMMANDS } = require('../../bin/paragon-scripts');
+const { helpCommand, findCommandByName } = require('../help');
+
+/* eslint-disable no-console */
+console.log = jest.fn();
+console.error = jest.fn();
+/* eslint-enable no-console */
+
+describe('helpCommand', () => {
+  beforeEach(() => {
+    /* eslint-disable no-console */
+    console.log.mockClear();
+    console.error.mockClear();
+    /* eslint-enable no-console */
+  });
+
+  it('displays all commands when no specific command is provided', () => {
+    helpCommand(COMMANDS, []);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith('Available commands:');
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('install-theme'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('build-tokens'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('version'));
+    /* eslint-enable no-console */
+  });
+
+  it('displays specific command details when command name is provided', () => {
+    helpCommand(COMMANDS, ['install-theme']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('install-theme'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('The @edx/brand package to install.'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Installs the specific @edx/brand package'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('theme'));
+    /* eslint-enable no-console */
+  });
+
+  it('displays error for unknown command', () => {
+    helpCommand(COMMANDS, ['unknown']);
+
+    expect(console.error).toHaveBeenCalledWith(/* eslint-disable-line no-console */
+      chalk.red.bold('Unknown command. Usage: paragon help <command>.'),
+    );
+  });
+
+  it('handles commands without parameters or options', () => {
+    helpCommand(COMMANDS, ['version']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('version'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Displays the current version of Paragon CLI'));
+    /* eslint-enable no-console */
+  });
+
+  it('handles parameters with choices', () => {
+    helpCommand(COMMANDS, ['help']);
+    expect(console.log).toHaveBeenCalledWith(/* eslint-disable-line no-console */
+      expect.stringContaining(
+        `${chalk.yellow.bold('command')} ${chalk.grey('[install-theme|build-tokens|replace-variables|build-scss], Default: \'\'')}`,
+      ),
+    );
+  });
+
+  it('handles options with choices', () => {
+    helpCommand(COMMANDS, ['replace-variables']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('replace-variables'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining(
+      'CLI to replace SCSS variables usages or definitions to CSS variables and vice versa in .scss files.',
+    ));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `${chalk.yellow.bold('-t, --replacementType')} ${chalk.grey('[usage|definition], Default: definition')}`,
+      ),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `${chalk.yellow.bold('-d, --direction')} ${chalk.grey('[scss-to-css|css-to-scss], Default: scss-to-css')}`,
+      ),
+    );
+    /* eslint-enable no-console */
+  });
+
+  it('handles commands with both parameters and options with choices', () => {
+    helpCommand(COMMANDS, ['build-scss']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('build-scss'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('CLI to compile Paragon\'s core and themes SCSS into CSS.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('--corePath')} ${chalk.grey('Default: styles/scss/core/core.scss')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Path to the theme\'s core SCSS file'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('--themesPath')} ${chalk.grey('Default: styles/css/themes')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Path to the directory that contains themes\' files'),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('themes/'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('light/'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('dark/'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('some_other_custom_theme/'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('where index.css has imported all other CSS files in the theme\'s subdirectory'),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('The script will output'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('You can provide any amount of themes'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('light.css, dark.css and some_other_custom_theme.css files'),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('(together with maps and minified versions).'),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('You can provide any amount of themes. Default to paragon\'s themes.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('--outDir')} ${chalk.grey('Default: ./dist')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Specifies directory where to out resulting CSS files.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('--defaultThemeVariants')} ${chalk.grey('Default: light')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Specifies default theme variants'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('You can provide multiple default theme variants'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('example: `--defaultThemeVariants light dark`'));
+    /* eslint-enable no-console */
+  });
+
+  it('handles commands with multiple options including list choices', () => {
+    helpCommand(COMMANDS, ['build-tokens']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('build-tokens'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('CLI to build Paragon design tokens.'),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-s, --source')} ${chalk.grey('Default: \'\'')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-t, --themes')} ${chalk.grey('Default: light')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Can be provided as a comma-separated list'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-v, --verbose')} ${chalk.grey('Default: false')}`),
+    );
+    /* eslint-enable no-console */
+  });
+
+  it('handles replace-variables command with parameters and options', () => {
+    helpCommand(COMMANDS, ['replace-variables']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('replace-variables'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'CLI to replace SCSS variables usages or definitions to CSS variables and vice versa in .scss files.',
+      ),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-p, --filePath')} ${chalk.grey('Default: \'\'')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Path to the file or directory where to replace variables.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-s, --source')} ${chalk.grey('Default: \'\'')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Type of replacement: usage or definition'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `${chalk.yellow.bold('-t, --replacementType')} ${chalk.grey('[usage|definition], Default: definition')}`,
+      ),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Type of replacement: usage or definition'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `${chalk.yellow.bold('-d, --direction')} ${chalk.grey('[scss-to-css|css-to-scss], Default: scss-to-css')}`,
+      ),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Map direction: css-to-scss or scss-to-css'));
+    /* eslint-enable no-console */
+  });
+
+  it('handles build-tokens command with options', () => {
+    helpCommand(COMMANDS, ['build-tokens']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('build-tokens'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('CLI to build Paragon design tokens.'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-s, --source')} ${chalk.grey('Default: \'\'')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Specify the source directory for design tokens.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-b, --build-dir')} ${chalk.grey('Default: ./build/')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Specify the build directory for the generated tokens.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('--source-tokens-only')} ${chalk.grey('Default: false')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Include only source design tokens in the build.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('--output-token-references')} ${chalk.grey('Default: true')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Include references for tokens with aliases to other tokens in the build output.'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-t, --themes')} ${chalk.grey('Default: light')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Specify themes to include in the token build.'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Can be provided as a comma-separated list'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('-v, --verbose')} ${chalk.grey('Default: false')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Enable verbose logging.'));
+    /* eslint-enable no-console */
+  });
+
+  it('handles migrate-to-openedx-scope command with parameters', () => {
+    helpCommand(COMMANDS, ['migrate-to-openedx-scope']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('migrate-to-openedx-scope'));
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('CLI for migrate from "@edx/paragon" to "@openedx/paragon".'),
+    );
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(`${chalk.yellow.bold('path')} ${chalk.grey('Default: None')}`),
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'Path to the directory where to replace Paragon package name, default to root of the repository',
+      ),
+    );
+    /* eslint-enable no-console */
+  });
+
+  it('handles help command with parameters', () => {
+    helpCommand(COMMANDS, ['help']);
+    /* eslint-disable no-console */
+    expect(console.log).toHaveBeenCalledWith(chalk.yellow.bold('Paragon Help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('help'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Displays help for available commands.'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `${chalk.yellow.bold('command')} ${chalk.grey('[install-theme|build-tokens|replace-variables|build-scss], Default: \'\'')}`,
+      ),
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Specifies command name.'));
+    /* eslint-enable no-console */
+  });
+});
+
+describe('findCommandByName', () => {
+  it('returns command object when command exists', () => {
+    const result = findCommandByName('help', COMMANDS);
+    expect(result).toEqual({ help: COMMANDS.help });
+  });
+
+  it('returns null when command does not exist', () => {
+    const result = findCommandByName('unknown', COMMANDS);
+    expect(result).toBeNull();
+  });
+});

package/lib/__tests__/install-theme.test.js

@@ -0,0 +1,66 @@
+const inquirer = require('inquirer');
+const childProcess = require('child_process');
+
+const themeCommand = require('../install-theme');
+
+jest.mock('inquirer');
+jest.mock('child_process');
+
+describe('install-theme', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.argv = ['node', 'script'];
+  });
+
+  describe('promptUserForTheme', () => {
+    it('should prompt user with correct default theme', async () => {
+      inquirer.prompt.mockResolvedValueOnce({ theme: '@openedx/brand-openedx@latest' });
+
+      await themeCommand();
+
+      expect(inquirer.prompt).toHaveBeenCalledWith([
+        expect.objectContaining({
+          type: 'input',
+          name: 'theme',
+          message: 'What @edx/brand package do you want to install?',
+          default: '@openedx/brand-openedx@latest',
+        }),
+      ]);
+    });
+  });
+
+  describe('installTheme', () => {
+    it('should install theme when provided via command line', async () => {
+      process.argv = ['node', 'script', 'install-theme', '@edx/custom-theme@1.0.0'];
+
+      await themeCommand();
+
+      expect(childProcess.execSync).toHaveBeenCalledWith(
+        'npm install "@edx/brand@npm:@edx/custom-theme@1.0.0" --no-save',
+        expect.any(Object),
+      );
+    });
+
+    it('should install theme when provided via prompt', async () => {
+      inquirer.prompt.mockResolvedValueOnce({ theme: '@edx/custom-theme@2.0.0' });
+
+      await themeCommand();
+
+      expect(childProcess.execSync).toHaveBeenCalledWith(
+        'npm install "@edx/brand@npm:@edx/custom-theme@2.0.0" --no-save',
+        expect.any(Object),
+      );
+    });
+
+    it('should handle empty theme input correctly', async () => {
+      inquirer.prompt.mockResolvedValueOnce({ theme: '' });
+
+      await themeCommand();
+
+      expect(childProcess.execSync).toHaveBeenCalledWith(
+        'npm install "@edx/brand@" --no-save',
+        expect.any(Object),
+      );
+    });
+  });
+});