feat: add helpers package

Author: thepassle

packages/helpers/helpers.js

@@ -0,0 +1,85 @@
+const has = arr => Array.isArray(arr) && arr?.length > 0;
+
+/** Package */
+export function hasModules(_package) {
+  return has(_package?.modules);
+}
+
+/** JavaScriptModule */
+export function hasExports(_module) {
+  return has(_module?.exports);
+}
+
+export function hasDeclarations(_module) {
+  return has(_module?.declarations);
+}
+
+export function isJavaScriptModule(_module) {
+  return _module.kind === 'javascript-module';
+}
+
+/** Exports */
+export function isCustomElementExport(_export) {
+  return _export.kind === 'custom-element-definition';
+}
+
+export function isJavaScriptExport(_export) {
+  return _export.kind === 'js';
+}
+
+/** Declarations */
+export function isClass(item) {
+  return item.kind === 'class';
+}
+
+export function isMixin(item) {
+  return item.kind === 'mixin';
+}
+
+export function isFunction(item) {
+  return item.kind === 'function';
+}
+
+export function isVariable(item) {
+  return item.kind === 'variable';
+}
+
+/** CustomElement */
+export function hasAttributes(customElement) {
+  return has(customElement?.attributes)
+}
+
+export function hasEvents(customElement) {
+  return has(customElement?.events)
+}
+
+export function hasSlots(customElement) {
+  return has(customElement?.slots)
+}
+
+export function hasMethods(customElement) {
+  return (
+    has(customElement?.members) &&
+    customElement?.members?.some(member => member.kind === 'method')
+  );
+}
+
+export function hasFields(customElement) {
+  return (
+    has(customElement?.members) &&
+    customElement?.members?.some(member => member.kind === 'field')
+  );
+}
+
+export function hasMixins(customElement) {
+  return has(customElement?.mixins);
+}
+
+/** ClassMember */
+export function isField(member) {
+  return member.kind === 'field';
+}
+
+export function isMethod(member) {
+  return member.kind === 'method';
+}

packages/helpers/index.js

@@ -0,0 +1,147 @@
+import * as h from './helpers.js';
+
+export class CustomElementsJson {
+  schemaVersion;
+  readme;
+  modules;
+  
+  _classes = new Map();
+  _tagNames = new Map();
+  _definitions = new Map();
+  _mixins = new Map();
+
+  constructor(
+    { schemaVersion, readme, modules } = {
+      schemaVersion: '0.1.0',
+      readme: '',
+      modules: [],
+    },
+  ) {
+    this.schemaVersion = schemaVersion;
+    this.readme = readme;
+    this.modules = modules;
+    this.init();
+  }
+
+  init() {
+    this.loopAll((item) => {
+      if (h.isClass(item)) {
+        this._classes.set(item.name, item);
+      }
+
+      if (h.isMixin(item)) {
+        this._mixins.set(item.name, item);
+      }
+
+      if (h.isCustomElementExport(item)) {
+        this._tagNames.set(
+          item.name,
+          this._classes.get(item.declaration.name),
+        );
+
+        this._definitions.set(item.name, item);
+      }
+    });
+  }
+
+  loopAll(cb) {
+    this.modules.forEach((mod) => {
+      mod?.exports?.forEach((ex) => {
+        cb(ex);
+      });
+
+      mod?.declarations?.forEach((declaration) => {
+        cb(declaration);
+      });
+    });
+  }
+
+  getByTagName(tagName) {
+    return this._tagNames.get(tagName);
+  }
+
+  getByClassName(className) {
+    return this._classes.get(className);
+  }
+
+  getByMixinName(mixinName) {
+    return this._mixins.get(mixinName);
+  }
+
+  /** 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()];
+  }
+
+  // @TODO
+  getInheritanceTree(className) {
+    const tree = [];
+
+    let klass = this._classes.get(className);
+
+    if (klass) {
+      tree.push(klass);
+
+      klass?.mixins?.forEach((mixin) => {
+        tree.push(this._mixins.get(mixin.name));
+      });
+
+      while (this._classes.has(klass.superclass.name)) {
+        const newKlass = this._classes.get(klass.superclass.name);
+
+        newKlass?.mixins?.forEach((mixin) => {
+          tree.push(this._mixins.get(mixin.name));
+        });
+
+        tree.push(newKlass);
+        klass = newKlass;
+      }
+
+      return tree;
+    }
+    return [];
+  }
+
+  getModuleForClass(className) {
+    let result = undefined;
+
+    this.modules.forEach((mod) => {
+      mod?.declarations?.forEach((declaration) => {
+        if (h.isClass(declaration) && declaration.name === className) {
+          result = mod.path;
+        }
+      });
+    });
+
+    return result;
+  }
+
+  getModuleForMixin(className) {
+    let result = undefined;
+
+    this.modules.forEach((mod) => {
+      mod?.declarations?.forEach((declaration) => {
+        if (h.isMixin(declaration) && declaration.name === className) {
+          result = mod.path;
+        }
+      });
+    });
+
+    return result;
+  }
+}