feat: update helpers

Author: thepassle

.github/workflows/main.yml

@@ -31,3 +31,5 @@ jobs:
           yarn
           cd packages/analyzer
           npm test
+          cd ../helpers
+          npm test

packages/helpers/README.md

@@ -0,0 +1,149 @@
+# @custom-elements-manifest/helpers
+
+Custom-elements.json is a file format that describes custom elements. This format will allow tooling and IDEs to give rich information about the custom elements in a given project.
+
+This library aims to ship some helpers to ease working with the `custom-elements.json` format.
+
+## Install
+
+```bash
+npm i -S @custom-elements-manifest/helpers
+```
+
+## Usage
+
+```js
+// Node
+import { CustomElementsJson } from '@custom-elements-manifest/helpers';
+
+const manifest = JSON.parse(fs.readFileSync('./custom-elements.json', 'utf-8'));
+const customElementsJson = new CustomElementsJson(manifest);
+
+// Browser
+import { CustomElementsJson } from 'https://unpkg.com/@custom-elements-manifest?module';
+import manifest from './custom-elements.json' assert { type: 'json' };
+
+const customElementsJson = new CustomElementsJson(manifest);
+```
+
+## Methods
+
+### `getByTagName`
+
+Gets a declaration by tagName
+
+```js
+customElementsJson.getByTagName('my-element');
+```
+
+### `getByClassName`
+Get a declaration by className
+
+```js
+customElementsJson.getByClassName('MyElement');
+```
+
+### `getByMixinName`
+Gets a declaration by mixinName
+
+```js
+customElementsJson.getByMixinName('MyElement');
+```
+### `getCustomElements`
+Gets all custom elements
+
+```js
+customElementsJson.getCustomElements();
+```
+
+### `getClasses`
+Gets all classes. Note that this may include classes that are not custom elements
+
+```js
+customElementsJson.getClasses();
+```
+
+### `getFunctions`
+Gets all functions
+
+```js
+customElementsJson.getFunctions();
+```
+
+### `getVariables`
+Gets all variables
+
+```js
+customElementsJson.getVariables();
+```
+
+### `getDefinitions`
+Gets all custom element definitions.
+
+```js
+customElementsJson.getDefinitions();
+```
+
+### `getMixins`
+Gets all mixins
+
+```js
+customElementsJson.getMixins();
+```
+
+### `getInheritanceTree`
+
+Gets an elements inheritance tree, including superclasses and mixins
+
+```js
+customElementsJson.getInheritanceTree('MyElement');
+```
+
+### `getModuleForClass`
+
+Gets the module path for a given class
+
+```js
+customElementsJson.getModuleForClass('MyElement');
+```
+
+### `getModuleForMixin`
+
+Gets the module path for a given mixin
+
+```js
+customElementsJson.getModuleForMixin('FooMixin');
+```
+
+## Helpers
+
+### Package
+- `hasModules`
+- `hasExports`
+- `hasDeclarations`
+- `isJavascriptModule`
+
+### Exports
+- `isCustomElementExport`
+- `isJavaScriptExport`
+
+### Declarations
+- `isClass`
+- `isMixin`
+- `isCustomElement`
+- `isFunction`
+- `isVariable`
+
+### CustomElement
+- `hasAttributes`
+- `hasCssParts`
+- `hasCssProperties`
+- `hasEvents`
+- `hasSlots`
+- `hasMethods`
+- `hasFields`
+- `hasMixins`
+
+### ClassMember
+- `isField`
+- `isMethod`

packages/helpers/helpers.js

@@ -36,6 +36,10 @@ export function isMixin(item) {
   return item.kind === 'mixin';
 }
 
+export function isCustomElement(item) {
+  return item.customElement;
+}
+
 export function isFunction(item) {
   return item.kind === 'function';
 }
@@ -49,6 +53,14 @@ export function hasAttributes(customElement) {
   return has(customElement?.attributes)
 }
 
+export function hasCssParts(customElement) {
+  return has(customElement?.cssParts)
+}
+
+export function hasCssProperties(customElement) {
+  return has(customElement?.cssProperties)
+}
+
 export function hasEvents(customElement) {
   return has(customElement?.events)
 }

packages/helpers/index.js

@@ -1,26 +1,19 @@
 import * as h from './helpers.js';
 
 export class CustomElementsJson {
-  schemaVersion;
-  readme;
-  modules;
-  
+  _functions = new Map();
+  _variables = new Map();
   _classes = new Map();
   _tagNames = new Map();
   _definitions = new Map();
   _mixins = new Map();
   _classLikes = new Map();
+  _customElements = new Map();
 
-  constructor(
-    { schemaVersion, readme, modules } = {
-      schemaVersion: '0.1.0',
-      readme: '',
-      modules: [],
-    },
-  ) {
-    this.schemaVersion = schemaVersion;
-    this.readme = readme;
-    this.modules = modules;
+  constructor(cem) {
+    for (const [key, value] of Object.entries(cem)) {
+      this[key] = value;
+    }
     this.init();
   }
 
@@ -31,6 +24,18 @@ export class CustomElementsJson {
         this._classLikes.set(item.name, item);
       }
 
+      if(h.isFunction(item)) {
+        this._functions.set(item.name, item);
+      }
+
+      if(h.isVariable(item)) {
+        this._variables.set(item.name, item);
+      }
+
+      if(h.isCustomElement(item)) {
+        this._customElements.set(item.name, item);
+      }
+
       if (h.isMixin(item)) {
         this._mixins.set(item.name, item);
         this._classLikes.set(item.name, item);
@@ -73,22 +78,31 @@ export class CustomElementsJson {
     return this._mixins.get(mixinName);
   }
 
+  /** Gets all customElements from declarations */
+  getCustomElements() {
+    return [...this._customElements.values()];
+  }
+
+  /** Gets all functions from declarations */
+  getFunctions() {
+    return [...this._functions.values()];
+  }
+
+  /** Gets all functions from declarations */
+  getVariables() {
+    return [...this._variables.values()];
+  }
+
   /** Gets all classes from declarations */
   getClasses() {
     return [...this._classes.values()];
   }
 
-  /** Gets registered custom elements, so elements that have customElements.define called, returns class including tagName */
-  getTagNames() {
-    return [...this._tagNames.values()];
-  }
-
   /** Gets all CustomElementDefinitions */
   getDefinitions() {
     return [...this._definitions.values()];
   }
 
-
   getMixins() {
     return [...this._mixins.values()];
   }

packages/helpers/test/fixtures/classes.json

@@ -16,6 +16,11 @@
           "customElement": true,
           "tagName": "my-element"
         },
+        {
+          "kind": "class",
+          "description": "",
+          "name": "Foo"
+        },
         {
           "kind": "class",
           "description": "",

packages/helpers/test/helpers.test.js

@@ -11,6 +11,8 @@ import {
   hasEvents,
   hasSlots,
   hasMethods,
+  hasCssParts,
+  hasCssProperties,
   hasFields,
   hasMixins,
   isField,
@@ -109,6 +111,8 @@ const fixtureF = {
   attributes: [{ name: 'foo' }],
   events: [{ name: 'foo', description: '', type: { text: '' } }],
   slots: [{ name: '' }],
+  cssParts: [{}],
+  cssProperties: [{}],
   members: [
     { kind: 'field', name: '' },
     { kind: 'method', name: '' },
@@ -132,6 +136,14 @@ helpers('hasEvents - false', () => {
   expect(hasEvents({ ...fixtureF, events: [] })).to.equal(false);
 });
 
+helpers('hasCssParts - true', () => {
+  expect(hasCssParts(fixtureF)).to.equal(true);
+});
+
+helpers('hasCssProperties - true', () => {
+  expect(hasCssProperties(fixtureF)).to.equal(true);
+});
+
 helpers('hasSlots - true', () => {
   expect(hasSlots(fixtureF)).to.equal(true);
 });

packages/helpers/test/index.test.js

@@ -26,14 +26,18 @@ test('getByClassName', () => {
 
 test('getClasses - gets all classes', () => {
   const customElementsJson = new CustomElementsJson(classes);
-  expect(customElementsJson.getClasses().length).to.equal(2);
+  expect(customElementsJson.getClasses().length).to.equal(3);
 });
 
 test('getDefinitions - gets all definitions', () => {
   const customElementsJson = new CustomElementsJson(classes);
   expect(customElementsJson.getDefinitions().length).to.equal(2);
 });
 
+test('getCustomElements - gets all custom elements', () => {
+  const customElementsJson = new CustomElementsJson(classes);
+  expect(customElementsJson.getCustomElements().length).to.equal(2);
+});
 
 test('getMixins - gets all mixins', () => {
   const customElementsJson = new CustomElementsJson(inheritanceMixinsSuperclass);