@muonic/muon 0.0.2-experimental-154-bdd17ca.0 → 0.0.2-experimental-156-ab51545.0

package/.nycrc

@@ -0,0 +1,17 @@
+{
+  "report-dir": "./coverage/scripts-coverage",
+  "reporter": [
+    "html",
+    "text"
+  ],
+  "exclude": [
+    "**/modular-scale.js",
+    "tests",
+    "tokens/**/string.js"
+  ],
+  "check-coverage": true,
+  "lines": 99,
+  "branches": 99,
+  "functions":99,
+  "statements": 99
+}

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.2-beta.0](https://github.com/centrica-engineering/muon/compare/v0.0.2-alpha.2...v0.0.2-beta.0) (2022-10-04)
+
+
+### Features
+
+* form comp ([8dd5fb6](https://github.com/centrica-engineering/muon/commit/8dd5fb66caeb0c3ed53a18497b6d4d00006d73a8))
+* layout-row tokens and styles ([e221d8a](https://github.com/centrica-engineering/muon/commit/e221d8a7677be49a24f7e3974b46c672d863171e))
+
+
+### Bug Fixes
+
+* analyzer ([018a59a](https://github.com/centrica-engineering/muon/commit/018a59a9f8e92b72f18a8d1f605dc8500aefeba0))
+* analyzer rollup ([ef8c7aa](https://github.com/centrica-engineering/muon/commit/ef8c7aaef0fe15cc0bbbb78945f0137ba89ee321))
+* analyzer to include components from node_modules ([32bace4](https://github.com/centrica-engineering/muon/commit/32bace4403dc007b84bb49bc59aa580351558c78))
+* automation failures ([238d9bf](https://github.com/centrica-engineering/muon/commit/238d9bf0c70576ef9a24ab8984fc7176656c2c23))
+* ava version ([1851f5e](https://github.com/centrica-engineering/muon/commit/1851f5e10c9a119a81e17e9afffdd14436f028ae))
+* browserstack test failure ([a471e5c](https://github.com/centrica-engineering/muon/commit/a471e5c7995a5564d034460b0dcca39aa344db07))
+* build error ([25b6a9d](https://github.com/centrica-engineering/muon/commit/25b6a9d166b5ab9f4e8aa5d67ab13f9fcd7d2551))
+* clean rollup output path ([7d37480](https://github.com/centrica-engineering/muon/commit/7d37480bbc770b790a47ea246956a25a83bffa7b))
+* cleanup dist before rollup ([24cb36a](https://github.com/centrica-engineering/muon/commit/24cb36a6a9a5fb6c823ceaa5e05a9cf3f0024f64))
+* cleanup muon files for every build & serve ([e8b76c3](https://github.com/centrica-engineering/muon/commit/e8b76c3d2d372dd54e00969d4598e7b7694f61a6))
+* cleanup util ([67b0e34](https://github.com/centrica-engineering/muon/commit/67b0e349fe9c06bc0310f9b0e7810a08477a9de5))
+* command injection ([8f529aa](https://github.com/centrica-engineering/muon/commit/8f529aa095b8ec1d64c8abf2ea5b3d42ba3813d8))
+* deplicate tag check ([7acd409](https://github.com/centrica-engineering/muon/commit/7acd4090a4e1ed3c352e3e3605c6308ea6f52f13))
+* **deps:** fixing build and tests ([388eea8](https://github.com/centrica-engineering/muon/commit/388eea8956d24bfedf1d54959ed912ec22ba61c7))
+* **deps:** packages ([a42388e](https://github.com/centrica-engineering/muon/commit/a42388e49a04c402d0aa8e5f34bab7c4109d1d51))
+* **deps:** update dependencies ([19f8736](https://github.com/centrica-engineering/muon/commit/19f8736f06fb1e48e7af41a6a40c02e1f19885ff))
+* **deps:** update vulnerabilities ([c0aad11](https://github.com/centrica-engineering/muon/commit/c0aad11e69d18a12cedf04927ed29247d3972648))
+* eslint warning ([789b296](https://github.com/centrica-engineering/muon/commit/789b2961c56365a7c01e2ea3b0d3141fb2aa41dc))
+* examples story path ([aa53050](https://github.com/centrica-engineering/muon/commit/aa530500a34b0c9fe50a0afa4c17926967033b7d))
+* lint errors ([5938f65](https://github.com/centrica-engineering/muon/commit/5938f6566c71217553f557428d107bc0eb8a59ab))
+* missing resolve dep ([f026873](https://github.com/centrica-engineering/muon/commit/f02687382dbf03d7f40f5a89835a5c488b9cd410))
+* remove redundent code ([a414686](https://github.com/centrica-engineering/muon/commit/a414686ccb33016c1c2101ce20df33252fab69b7))
+* remove staticHTML from template ([23196a3](https://github.com/centrica-engineering/muon/commit/23196a32b42652a726a0c82e7884e78f9790ab58))
+* remove test ([41e7bbb](https://github.com/centrica-engineering/muon/commit/41e7bbb5e3127ca8a00c97a110986677be787a71))
+* reset test fixtures ([1bf64f4](https://github.com/centrica-engineering/muon/commit/1bf64f4bc15c36396027a402d14eefbc277a0ff8))
+* reset value ([b8682ee](https://github.com/centrica-engineering/muon/commit/b8682ee9b3deb7022cd49040f1264f417223c30f))
+* reset web component values ([40da965](https://github.com/centrica-engineering/muon/commit/40da9653e76474d973e766951c5ddf9c6249df6e))
+* test failure ([694fc36](https://github.com/centrica-engineering/muon/commit/694fc360c4db676b649aa64eb508fe30adf51b46))
+* test failure ([16d0075](https://github.com/centrica-engineering/muon/commit/16d00750d5383755025e41e49adba5cc01b834cf))
+* test failures ([c6fd411](https://github.com/centrica-engineering/muon/commit/c6fd41117c5201218721bc0c2501a5e4fca3fb93))
+* tmp directory skip ([58e9333](https://github.com/centrica-engineering/muon/commit/58e9333db57dac6400e2e612232125d8dcf56331))
+
 ### [0.0.2-alpha.2](https://github.com/centrica-engineering/muon/compare/v0.0.2-alpha.1...v0.0.2-alpha.2) (2022-04-07)
 
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@muonic/muon",
-  "version": "0.0.2-experimental-154-bdd17ca.0",
+  "version": "0.0.2-experimental-156-ab51545.0",
   "description": "",
   "main": "index.js",
   "scripts": {
     "test": "web-test-runner \"./tests/**/*.test.js\" --coverage",
-    "test:scripts": "ava \"tests/scripts/utils/utils-test.js\"",
+    "test:scripts": "NODE_OPTIONS=--loader=esmock c8 ava \"tests/scripts/utils/utils-test.mjs\"",
     "test:browserstack": "web-test-runner \"./tests/**/*.test.js\" --config web-test-runner.browserstack.config.mjs",
     "release": "standard-version"
   },
@@ -58,6 +58,8 @@
     "@web/test-runner-browserstack": "0.5.1",
     "@web/test-runner-playwright": "0.8.10",
     "ava": "4.3.3",
+    "c8": "^7.12.0",
+    "esmock": "^2.0.3",
     "sinon": "14.0.0"
   },
   "engines": {

package/scripts/utils/config.mjs

@@ -0,0 +1,30 @@
+import path from 'path';
+import appRoot from 'app-root-path';
+import fs from 'fs';
+
+const getConfig = (configFile = 'muon.config.json') => {
+  let config = {};
+  try {
+    let configPath = path.join(process.cwd(), configFile);
+
+    if (!fs.existsSync(configPath)) {
+      configPath = path.join(`${appRoot}/${configFile}`);
+    }
+    config = JSON.parse(fs.readFileSync(configPath).toString());
+  } catch (e) {
+    console.error('Missing config, is this the right folder?', e);
+    process.exit(1);
+  }
+
+  return config;
+};
+
+const getDestination = () => {
+  const config = getConfig();
+  return config?.destination || 'dist';
+};
+
+export {
+  getConfig,
+  getDestination
+};

package/scripts/utils/index.mjs

@@ -13,14 +13,12 @@ import styleConfig from '../style-dictionary.mjs';
 import colorTransform from '../../tokens/utils/transforms/color.js';
 import stringTransform from '../../tokens/utils/transforms/string.js';
 import jsonReference from '../../tokens/utils/formats/reference.js';
-
+import { getConfig, getDestination } from './config.mjs';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-let config = {};
-
 const cleanup = (destination, cleanOnRollup = false) => {
   return new Promise((resolve) => {
     const cemFilePath = path.join(destination, 'custom-elements.json');
@@ -29,10 +27,9 @@ const cleanup = (destination, cleanOnRollup = false) => {
     if (fs.existsSync(destination)) {
       if (cleanOnRollup) {
         // eslint-disable-next-line no-unused-expressions
-        fs.existsSync(cemFilePath) && fs.rmSync(cemFilePath);
+        fs.rmSync(cemFilePath, { force: true });
       } else {
         fs.rmSync(destination, { force: true, recursive: true });
-        fs.rmSync(buildPath, { force: true, recursive: true });
       }
     }
 
@@ -40,28 +37,13 @@ const cleanup = (destination, cleanOnRollup = false) => {
       fs.mkdirSync(destination);
     }
     if (!cleanOnRollup) {
+      fs.rmSync(buildPath, { force: true, recursive: true });
       fs.mkdirSync(buildPath);
     }
     return resolve();
   });
 };
 
-const getConfig = (configFile = 'muon.config.json') => {
-  try {
-    let configPath = path.join(process.cwd(), configFile);
-
-    if (!fs.existsSync(configPath)) {
-      configPath = path.join(`${appRoot}/${configFile}`);
-    }
-    config = JSON.parse(fs.readFileSync(configPath).toString());
-  } catch (e) {
-    console.error('Missing config, is this the right folder?', e);
-    process.exit(1);
-  }
-
-  return config;
-};
-
 const filterPathToCustomElements = async (componentsList) => {
   let pathPattern = '*';
   if (Array.isArray(componentsList) && componentsList?.length > 0) {
@@ -165,7 +147,7 @@ const getAliasPaths = (type) => {
         find,
         replacement: path.join(process.cwd(), replacement)
       };
-    }).filter((alias) => alias) ?? [];
+    }).filter((alias) => alias);
 
     const defaultAlias = objGlobToRegexArr(defaultPaths);
 
@@ -197,8 +179,7 @@ const sourceFilesAnalyzer = async () => {
     baseUrl: '.',
     paths
   };
-  const filePaths = Array.isArray(files) ? files : [files];
-  const program = ts.createProgram(filePaths, options);
+  const program = ts.createProgram(files, options);
   const sourceFiles = program.getSourceFiles().filter((sf) => files.includes(sf.fileName));
 
   const results = sourceFiles.map((sourceFile) => analyzeSourceFile(sourceFile, {
@@ -281,11 +262,6 @@ const componentDefiner = async () => {
   return componentDefinition;
 };
 
-const getDestination = () => {
-  const config = getConfig();
-  return config?.destination || 'dist';
-};
-
 const runner = async (file, overrideDestination) => {
   const destination = overrideDestination || getDestination();
 

package/tests/scripts/utils/card-component.js

@@ -0,0 +1,26 @@
+import { Card } from '@muonic/muon/components/card';
+
+/**
+ * A fancier version of the card.
+ *
+ * @element card
+ *
+ */
+
+export class FancyCard extends Card {
+
+  static get properties() {
+    return {
+      fancy: { type: Boolean }
+    };
+  }
+
+  get coolBean() {
+    return 'cool beans';
+  }
+
+  something() {
+    return 'doing something';
+  }
+
+}

package/tests/scripts/utils/muon.config.test.json

@@ -0,0 +1,13 @@
+{
+  "components": {
+    "included": ["inputter" ,"card","image"],
+    "dir": "tests/scripts/utils/*-component.js"
+  },
+  "tokens": {
+    "dir": ["tokens/*.json"],
+    "theme": "default"
+  },
+  "alias": {
+    "@muon/utils/validation": "./utils/validation"
+  }
+}

package/tests/scripts/utils/single.component.config.json

@@ -0,0 +1,5 @@
+{
+  "components": {
+    "included": ["card"]
+  }
+}

package/tests/scripts/utils/test-runner.mjs

@@ -0,0 +1 @@
+console.log('test runner function');

package/tests/scripts/utils/utils-test.mjs

@@ -0,0 +1,284 @@
+import testRunner from 'ava';
+import sinon from 'sinon';
+import appRoot from 'app-root-path';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import esmock from 'esmock';
+import * as utilsLibrary from '../../../scripts/utils/index.mjs';
+
+testRunner('filterPathToCustomElements default', async (t) => {
+  const componentList = await utilsLibrary.filterPathToCustomElements('all');
+  t.is(componentList, '*');
+});
+
+testRunner('filterPathToCustomElements default array', async (t) => {
+  const componentList = await utilsLibrary.filterPathToCustomElements(['all']);
+  t.is(componentList, '*');
+});
+
+testRunner('filterPathToCustomElements single component', async (t) => {
+  const componentList = await utilsLibrary.filterPathToCustomElements('inputter');
+  t.is(componentList, 'inputter');
+});
+
+testRunner('filterPathToCustomElements single component in array', async (t) => {
+  const componentList = await utilsLibrary.filterPathToCustomElements(['inputter']);
+  t.is(componentList, 'inputter');
+});
+
+testRunner('filterPathToCustomElements multiple component', async (t) => {
+  const componentList = await utilsLibrary.filterPathToCustomElements(['inputter', 'image']);
+  t.is(componentList, '{inputter,image}');
+});
+
+testRunner('getConfig default file and root', async (t) => {
+  const config = utilsLibrary.getConfig();
+  t.true(config !== undefined);
+});
+
+testRunner('getConfig new file default root', async (t) => {
+  const config = utilsLibrary.getConfig('browserstack.json');
+  t.true(config !== undefined);
+});
+
+testRunner('getConfig config file not exist', async (t) => {
+  const stub = sinon.stub(process, 'exit');
+  utilsLibrary.getConfig('test.json');
+  t.true(process.exit.called);
+  t.true(process.exit.calledWith(1));
+  stub.restore();
+});
+
+testRunner('getConfig config file', async (t) => {
+  const config = utilsLibrary.getConfig('tests/scripts/utils/muon.config.test.json');
+  t.true(config !== undefined);
+});
+
+const componentsDefinitionMacro = async (t, expected) => {
+  const componentDefinition = await utilsLibrary.componentDefiner();
+  t.true(componentDefinition !== undefined);
+  t.true(componentDefinition.indexOf(`import '@webcomponents/scoped-custom-element-registry';`) > -1);
+  Object.keys(expected).forEach((component) => {
+    t.true(componentDefinition.indexOf(`import { ${expected[component]} } from '${process.cwd()}/components/${component}/src/${component}-component.js';`) > -1);
+    t.true(componentDefinition.indexOf(`customElements.define('muon-${component}', ${expected[component]});`) > -1);
+  });
+};
+componentsDefinitionMacro.title = (providedTitle, expected) => `${providedTitle} => ${Object.keys(expected)}`;
+
+testRunner('componentDefiner', componentsDefinitionMacro, { card: 'Card', cta: 'Cta', detail: 'Detail', form: 'Form', icon: 'Icon', inputter: 'Inputter', image: 'Image' });
+
+testRunner('getAliasPath glob', async (t) => {
+  const alias = utilsLibrary.getAliasPaths('glob');
+
+  t.deepEqual(alias, {
+    '@muon/components/*': [`${appRoot}/node_modules/@muonic/muon/components/*`],
+    '@muon/mixins/*': [`${appRoot}/node_modules/@muonic/muon/mixins/*`],
+    '@muon/directives/*': [`${appRoot}/node_modules/@muonic/muon/directives/*`],
+    '@muon/utils/*': [`${appRoot}/node_modules/@muonic/muon/utils/*`],
+    '@muon/tokens': [`${appRoot}/node_modules/@muonic/muon/build/tokens/es6/muon-tokens`]
+  });
+});
+
+testRunner('getAliasPath regex', async (t) => {
+  const alias = utilsLibrary.getAliasPaths('regex');
+  t.deepEqual(alias, [
+    {
+      find: /^@muon\/components\/(.*)$/,
+      replacement: '@muonic/muon/components/$1'
+    },
+    {
+      find: /^@muon\/mixins\/(.*)$/,
+      replacement: '@muonic/muon/mixins/$1'
+    },
+    {
+      find: /^@muon\/directives\/(.*)$/,
+      replacement: '@muonic/muon/directives/$1'
+    },
+    {
+      find: /^@muon\/utils\/(.*)$/,
+      replacement: '@muonic/muon/utils/$1'
+    },
+    {
+      find: /^@muon\/tokens$/,
+      replacement: '@muonic/muon/build/tokens/es6/muon-tokens'
+    }
+  ]);
+});
+
+testRunner('getAliasPath invalid', async (t) => {
+  const alias = utilsLibrary.getAliasPaths('invalid');
+  t.true(alias === undefined);
+});
+
+testRunner('getAliasPath config alias regex', async (t) => {
+  const stub = await esmock('../../../scripts/utils/index.mjs', {
+    '../../../scripts/utils/config.mjs': {
+      getConfig: (configFile) => JSON.parse(fs.readFileSync('tests/scripts/utils/muon.config.test.json').toString())
+    }
+  });
+  const alias = stub.getAliasPaths('regex');
+  t.true(alias !== undefined);
+  t.deepEqual(alias, [
+    {
+      find: /^@muon\/utils\/validation$/,
+      replacement: `${process.cwd()}/utils/validation`
+    },
+    {
+      find: /^@muon\/components\/(.*)$/,
+      replacement: '@muonic/muon/components/$1'
+    },
+    {
+      find: /^@muon\/mixins\/(.*)$/,
+      replacement: '@muonic/muon/mixins/$1'
+    },
+    {
+      find: /^@muon\/directives\/(.*)$/,
+      replacement: '@muonic/muon/directives/$1'
+    },
+    {
+      find: /^@muon\/utils\/(.*)$/,
+      replacement: '@muonic/muon/utils/$1'
+    },
+    {
+      find: /^@muon\/tokens$/,
+      replacement: '@muonic/muon/build/tokens/es6/muon-tokens'
+    }
+  ]);
+});
+
+testRunner('getAliasPath config alias glob', async (t) => {
+  const stub = await esmock('../../../scripts/utils/index.mjs', {
+    '../../../scripts/utils/config.mjs': {
+      getConfig: (configFile) => JSON.parse(fs.readFileSync('tests/scripts/utils/muon.config.test.json').toString())
+    }
+  });
+  const alias = stub.getAliasPaths('glob');
+  t.true(alias !== undefined);
+  t.deepEqual(alias, {
+    '@muon/utils/validation': ['./utils/validation'],
+    '@muon/components/*': [
+      `${appRoot}/node_modules/@muonic/muon/components/*`
+    ],
+    '@muon/mixins/*': [
+      `${appRoot}/node_modules/@muonic/muon/mixins/*`
+    ],
+    '@muon/directives/*': [
+      `${appRoot}/node_modules/@muonic/muon/directives/*`
+    ],
+    '@muon/utils/*': [
+      `${appRoot}/node_modules/@muonic/muon/utils/*`
+    ],
+    '@muon/tokens': [
+      `${appRoot}/node_modules/@muonic/muon/build/tokens/es6/muon-tokens`
+    ]
+  });
+});
+
+testRunner('sourceFilesAnalyzer', async (t) => {
+  const result = await utilsLibrary.sourceFilesAnalyzer();
+  const jsonResult = JSON.parse(result);
+
+  const components = ['card', 'cta', 'detail', 'form', 'icon', 'image', 'inputter', 'inputter-detail'];
+  const propertiesMap = {
+    card: ['standardTemplate', 'image', 'alt', 'background', 'type'],
+    cta: ['href', 'standardTemplate', 'submitTemplate', 'resetTemplate', 'loading', 'loadingMessage', 'disabled', 'icon', 'type'],
+    detail: ['icon', 'standardTemplate', 'open', 'type'],
+    form: ['standardTemplate', 'type'],
+    icon: ['size', 'sizes', 'iconSize', 'standardTemplate', 'name', 'category', 'allSizes', 'url', 'describe', 'type'],
+    image: ['src', 'placeholderImage', 'standardTemplate', 'background', 'backgroundsize', 'alt', 'ratio', 'placeholder', 'loading', 'type'],
+    inputter: ['helper', 'slottedStyles', 'isHelperOpen', 'isPristine', 'isDirty', 'validity', 'validationMessage', 'validation', 'disableNative', 'showMessage', 'name', 'value', 'labelID', 'heading', 'mask', 'separator', 'type'],
+    'inputter-detail': ['icon', 'standardTemplate', 'open', 'type']
+  };
+  t.deepEqual(jsonResult.tags?.map((tag) => tag.name), components);
+
+  components.forEach((component) => {
+    t.deepEqual(jsonResult.tags.filter((tag) => tag.name === component)[0].properties?.map(
+      (property) => property.name), propertiesMap[component]);
+  });
+  jsonResult.tags?.map((tag) => {
+    t.true(tag.description !== undefined, `${tag.name} description is not present`);
+  });
+});
+
+testRunner('sourceFilesAnalyzer error', async (t) => {
+  const stub = await esmock('../../../scripts/utils/index.mjs', {
+    '../../../scripts/utils/config.mjs': {
+      getConfig: (configFile) => JSON.parse(fs.readFileSync('tests/scripts/utils/muon.config.test.json').toString())
+    }
+  });
+  const sinonStub = sinon.stub(process, 'exit');
+  await stub.sourceFilesAnalyzer();
+  t.true(process.exit.called);
+  t.true(process.exit.calledWith(1));
+  sinonStub.restore();
+});
+
+testRunner('sourceFilesAnalyzer single file', async (t) => {
+  const stub = await esmock('../../../scripts/utils/index.mjs', {
+    '../../../scripts/utils/config.mjs': {
+      getConfig: (configFile) => JSON.parse(fs.readFileSync('tests/scripts/utils/single.component.config.json').toString())
+    }
+  });
+  const result = await stub.sourceFilesAnalyzer();
+  const jsonResult = JSON.parse(result);
+
+  const components = ['card'];
+  const propertiesMap = {
+    card: ['standardTemplate', 'image', 'alt', 'background', 'type'],
+  };
+  t.deepEqual(jsonResult.tags?.map((tag) => tag.name), components);
+
+  components.forEach((component) => {
+    t.deepEqual(jsonResult.tags.filter((tag) => tag.name === component)[0].properties?.map(
+      (property) => property.name), propertiesMap[component]);
+  });
+  jsonResult.tags?.map((tag) => {
+    t.true(tag.description !== undefined, `${tag.name} description is not present`);
+  });
+});
+
+testRunner('create tokens', async (t) => {
+  await utilsLibrary.createTokens();
+  t.true(fs.existsSync(path.join(process.cwd(), 'build', 'tokens', 'css', 'mn-fonts.css')), 'font css file not exist');
+  t.true(fs.existsSync(path.join(process.cwd(), 'build', 'tokens', 'es6', 'muon-tokens-module.js')), 'muon-tokens-module.js don\'t exist');
+  t.true(fs.existsSync(path.join(process.cwd(), 'build', 'tokens', 'es6', 'muon-tokens.js')), 'muon-tokens.js don\'t exist');
+  t.true(fs.existsSync(path.join(process.cwd(), 'build', 'tokens', 'es6', 'muon-tokens.mjs')), 'muon-tokens.mjs don\'t exist');
+  t.true(fs.existsSync(path.join(process.cwd(), 'build', 'tokens', 'json', 'muon-tokens-reference.json')), 'muon-tokens-reference.json don\'t exist');
+});
+
+testRunner('getDestination', async (t) => {
+  const destination = utilsLibrary.getDestination();
+  t.is(destination, 'dist');
+});
+
+testRunner('runner', async (t) => {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  utilsLibrary.runner(path.join(__dirname, 'test-runner.mjs'));
+  t.pass();
+});
+
+testRunner('cleanup on rollup', async (t) => {
+  const destination = utilsLibrary.getDestination();
+  const cemPath = path.join(destination, 'custom-elements.json');
+  if (!fs.existsSync(destination)) {
+    fs.mkdirSync(destination);
+  }
+  fs.openSync(cemPath, 'w');
+  t.true(fs.existsSync(destination));
+  t.true(fs.existsSync(cemPath));
+  utilsLibrary.cleanup(destination, true);
+  t.true(fs.existsSync(destination));
+  t.false(fs.existsSync(cemPath));
+});
+
+testRunner('cleanup on serve', async (t) => {
+  const destination = utilsLibrary.getDestination();
+  if (!fs.existsSync(destination)) {
+    fs.mkdirSync(destination);
+  }
+  t.true(fs.existsSync(destination));
+  utilsLibrary.cleanup(destination);
+  t.true(fs.existsSync(destination));
+});

package/tests/scripts/utils/test.json

@@ -1,9 +0,0 @@
-{
-  "components": {
-    "included": "inputter,card,image"
-  },
-  "tokens": {
-    "dir": ["tokens/*.json"],
-    "theme": "default"
-  }
-}

package/tests/scripts/utils/utils-test.js

@@ -1,134 +0,0 @@
-const testRunner = require('ava');
-const sinon = require('sinon');
-const appRoot = require('app-root-path');
-
-let utilsLibrary;
-testRunner.before(async () => {
-  await import('../../../scripts/utils/index.mjs').then((utils) => {
-    utilsLibrary = utils;
-  });
-});
-
-testRunner('filterPathToCustomElements default', async (t) => {
-  const componentList = await utilsLibrary.filterPathToCustomElements('all');
-  t.is(componentList, '*');
-});
-
-testRunner('filterPathToCustomElements default array', async (t) => {
-  const componentList = await utilsLibrary.filterPathToCustomElements(['all']);
-  t.is(componentList, '*');
-});
-
-testRunner('filterPathToCustomElements single component', async (t) => {
-  const componentList = await utilsLibrary.filterPathToCustomElements('inputter');
-  t.is(componentList, 'inputter');
-});
-
-testRunner('filterPathToCustomElements single component in array', async (t) => {
-  const componentList = await utilsLibrary.filterPathToCustomElements(['inputter']);
-  t.is(componentList, 'inputter');
-});
-
-testRunner('filterPathToCustomElements multiple component', async (t) => {
-  const componentList = await utilsLibrary.filterPathToCustomElements(['inputter', 'image']);
-  t.is(componentList, '{inputter,image}');
-});
-
-testRunner('getConfig default file and root', async (t) => {
-  const config = utilsLibrary.getConfig();
-  t.true(config !== undefined);
-});
-
-testRunner('getConfig new file default root', async (t) => {
-  const config = utilsLibrary.getConfig('browserstack.json');
-  t.true(config !== undefined);
-});
-
-testRunner('getConfig config file not exist', async (t) => {
-  sinon.stub(process, 'exit');
-  utilsLibrary.getConfig('test.json');
-  t.true(process.exit.called);
-  t.true(process.exit.calledWith(1));
-});
-
-testRunner('getConfig config file', async (t) => {
-  const config = utilsLibrary.getConfig('tests/scripts/utils/test.json');
-  t.true(config !== undefined);
-});
-
-const componentsDefinitionMacro = async (t, expected) => {
-  const componentDefinition = await utilsLibrary.componentDefiner();
-  t.true(componentDefinition !== undefined);
-  t.true(componentDefinition.indexOf(`import '@webcomponents/scoped-custom-element-registry';`) > -1);
-  Object.keys(expected).forEach((component) => {
-    t.true(componentDefinition.indexOf(`import { ${expected[component]} } from '${process.cwd()}/components/${component}/src/${component}-component.js';`) > -1);
-    t.true(componentDefinition.indexOf(`customElements.define('muon-${component}', ${expected[component]});`) > -1);
-  });
-};
-componentsDefinitionMacro.title = (providedTitle, expected) => `${providedTitle} => ${Object.keys(expected)}`;
-
-testRunner('componentDefiner', componentsDefinitionMacro, { card: 'Card', cta: 'Cta', detail: 'Detail', form: 'Form', icon: 'Icon', inputter: 'Inputter', image: 'Image' });
-
-testRunner('getAliasPath glob', async (t) => {
-  const alias = utilsLibrary.getAliasPaths('glob');
-
-  t.deepEqual(alias, {
-    '@muon/components/*': [`${appRoot}/node_modules/@muonic/muon/components/*`],
-    '@muon/mixins/*': [`${appRoot}/node_modules/@muonic/muon/mixins/*`],
-    '@muon/directives/*': [`${appRoot}/node_modules/@muonic/muon/directives/*`],
-    '@muon/utils/*': [`${appRoot}/node_modules/@muonic/muon/utils/*`],
-    '@muon/tokens': [`${appRoot}/node_modules/@muonic/muon/build/tokens/es6/muon-tokens`]
-  });
-});
-
-testRunner('getAliasPath regex', async (t) => {
-  const alias = utilsLibrary.getAliasPaths('regex');
-  t.deepEqual(alias, [
-    {
-      find: /^@muon\/components\/(.*)$/,
-      replacement: '@muonic/muon/components/$1'
-    },
-    {
-      find: /^@muon\/mixins\/(.*)$/,
-      replacement: '@muonic/muon/mixins/$1'
-    },
-    {
-      find: /^@muon\/directives\/(.*)$/,
-      replacement: '@muonic/muon/directives/$1'
-    },
-    {
-      find: /^@muon\/utils\/(.*)$/,
-      replacement: '@muonic/muon/utils/$1'
-    },
-    {
-      find: /^@muon\/tokens$/,
-      replacement: '@muonic/muon/build/tokens/es6/muon-tokens'
-    }
-  ]);
-});
-
-testRunner('sourceFilesAnalyzer', async (t) => {
-  const result = await utilsLibrary.sourceFilesAnalyzer();
-  const jsonResult = JSON.parse(result);
-
-  const components = ['card', 'cta', 'detail', 'form', 'icon', 'image', 'inputter', 'inputter-detail'];
-  const propertiesMap = {
-    card: ['standardTemplate', 'image', 'alt', 'background', 'type'],
-    cta: ['href', 'standardTemplate', 'submitTemplate', 'resetTemplate', 'loading', 'loadingMessage', 'disabled', 'icon', 'type'],
-    detail: ['icon', 'standardTemplate', 'open', 'type'],
-    form: ['standardTemplate', 'type'],
-    icon: ['size', 'sizes', 'iconSize', 'standardTemplate', 'name', 'category', 'allSizes', 'url', 'describe', 'type'],
-    image: ['src', 'placeholderImage', 'standardTemplate', 'background', 'backgroundsize', 'alt', 'ratio', 'placeholder', 'loading', 'type'],
-    inputter: ['helper', 'slottedStyles', 'isHelperOpen', 'isPristine', 'isDirty', 'validity', 'validationMessage', 'validation', 'disableNative', 'showMessage', 'name', 'value', 'labelID', 'heading', 'mask', 'separator', 'type'],
-    'inputter-detail': ['icon', 'standardTemplate', 'open', 'type']
-  };
-  t.deepEqual(jsonResult.tags?.map((tag) => tag.name), components);
-
-  components.forEach((component) => {
-    t.deepEqual(jsonResult.tags.filter((tag) => tag.name === component)[0].properties?.map(
-      (property) => property.name), propertiesMap[component]);
-  });
-  jsonResult.tags?.map((tag) => {
-    t.true(tag.description !== undefined, `${tag.name} description is not present`);
-  });
-});