@dooboostore/simple-web-component 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dooboostore/simple-web-component",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "license": "MIT",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -92,10 +92,10 @@
     "webpack": "^5.93.0",
     "webpack-cli": "^5.1.4",
     "webpack-dev-server": "^5.2.0",
-    "@dooboostore/core": "1.0.30",
+    "@dooboostore/core-web": "1.0.10",
     "@dooboostore/core-node": "1.0.12",
     "@dooboostore/simple-boot": "1.0.54",
-    "@dooboostore/core-web": "1.0.10"
+    "@dooboostore/core": "1.0.30"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/src/decorators/addEventListener.ts

@@ -44,3 +44,12 @@ export const getAddEventListenerMetadata = (target: any): AddEventListenerMetada
   const constructor = target instanceof Function ? target : target.constructor;
   return ReflectUtils.getMetadata(ADD_EVENT_LISTENER_METADATA_KEY, constructor);
 };
+
+/**
+ * @addEventListenerHost decorator - simplified version of @addEventListener for :host selector
+ * Usage: @addEventListenerHost('click')
+ * Usage: @addEventListenerHost('click', { stopPropagation: true })
+ */
+export function addEventListenerHost(type: string, options?: AddEventListenerBaseOptions & SwcQueryOptions): MethodDecorator {
+  return addEventListener(':host', type, options);
+}

package/src/decorators/applyNode.ts

@@ -0,0 +1,290 @@
+import { ReflectUtils } from '@dooboostore/core';
+import { ensureInit, getElementConfig } from './elementDefine';
+import { SwcRootType } from '../types';
+
+export type ApplyNodePosition = 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd' | 'replace' | 'replaceChildren' | 'innerHtml' | 'innerText' | 'remove';
+
+export interface ApplyNodeOptions {
+  position?: ApplyNodePosition;
+  root?: SwcRootType;
+}
+
+export interface ApplyNodeMetadata {
+  propertyKey: string | symbol;
+  selector: string;
+  options: ApplyNodeOptions;
+}
+
+export const APPLY_NODE_METADATA_KEY = Symbol('simple-web-component:apply-node');
+
+const normalizeNodes = (res: any, doc: Document): Node[] => {
+  const items = Array.isArray(res) ? res : [res];
+  return items.map(it => {
+    if (it instanceof Node) return it;
+    return doc.createTextNode(it !== undefined && it !== null ? String(it) : '');
+  });
+};
+
+/**
+ * @applyNode decorator to surgically add/replace nodes to a target element.
+ * 
+ * Usage examples:
+ *   @applyNode('#list') addItem() { return '<li>New Item</li>'; }  // append at end
+ *   @applyNode('#header', { position: 'afterBegin' }) prependItem() { return '<h1>Title</h1>'; }  // prepend at start
+ *   @applyNode('#item', { position: 'replace' }) replaceItem() { return '<div>Replaced</div>'; }  // replace element
+ *   @applyNode('#list', { position: 'replaceChildren' }) updateList() { return [item1, item2]; }  // replace all children
+ *   @applyNode('#notification', { position: 'remove' }) dismissNotification() { return shouldDismiss; }  // remove if truthy
+ *   @applyNode('.items', { position: 'remove', root: 'shadow' }) clearItems() { return true; }  // remove shadow DOM elements
+ * 
+ * Positions:
+ *   - 'beforeEnd' (default): Append at end of target
+ *   - 'afterBegin': Prepend at start of target
+ *   - 'beforeBegin': Insert before target
+ *   - 'afterEnd': Insert after target
+ *   - 'replace': Replace the entire target element
+ *   - 'replaceChildren': Replace all children of target element
+ *   - 'innerHtml': Set target's innerHTML
+ *   - 'innerText': Set target's innerText
+ *   - 'remove': Remove target element if returned value is truthy
+ * 
+ * Root Options:
+ *   - 'auto' (default): Search shadow DOM first, then light DOM
+ *   - 'shadow': Search only in shadow DOM
+ *   - 'light': Search only in light DOM
+ *   - 'all': Use both (shadow preferred for query, both for remove)
+ */
+export function applyNode(selector: string, options: ApplyNodeOptions = { position: 'beforeEnd' }): MethodDecorator {
+  return (target: Object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+    const constructor = target.constructor;
+    let metaList = ReflectUtils.getOwnMetadata(APPLY_NODE_METADATA_KEY, constructor) as Map<string | symbol, ApplyNodeMetadata>;
+    if (!metaList) {
+      metaList = new Map<string | symbol, ApplyNodeMetadata>();
+      ReflectUtils.defineMetadata(APPLY_NODE_METADATA_KEY, metaList, constructor);
+    }
+    metaList.set(propertyKey, { propertyKey, selector, options });
+
+    const original = descriptor.value;
+    descriptor.value = async function (...args: any[]) {
+      ensureInit(this);
+      const res = await original.apply(this, args);
+      if (res !== undefined) {
+        const conf = getElementConfig(this);
+        const currentWin = (this as any)._resolveWindow?.(conf) || ((typeof window !== 'undefined' ? window : undefined) as Window);
+        const currentDoc = currentWin.document;
+
+        const pos = options.position || 'beforeEnd';
+        const r = options.root || 'auto';
+
+        const getTargetRoot = () => {
+          if (r === 'shadow') return this.shadowRoot;
+          if (r === 'light') return this as any;
+          if (r === 'all') return this.shadowRoot || (this as any);
+          return this.shadowRoot || (this as any); // auto
+        };
+
+        if (pos === 'remove') {
+          // Remove element(s) if returned value is truthy
+          if (res) {
+            if (selector === ':host' || !selector) {
+              if (r === 'shadow' && this.shadowRoot) {
+                // Remove all children from shadow DOM
+                this.shadowRoot.replaceChildren();
+              } else {
+                // Remove the component itself
+                (this as any).remove();
+              }
+            } else {
+              const targetRoot = getTargetRoot();
+              if (targetRoot) {
+                const targets = targetRoot.querySelectorAll(selector);
+                targets.forEach((el: Element) => el.remove());
+              }
+            }
+          }
+        } else {
+          let targetEl: any = null;
+          if (selector === ':host' || !selector) {
+            if (r === 'shadow') {
+              targetEl = this.shadowRoot;  // Target shadow DOM root
+            } else {
+              targetEl = this as any;  // Target the component itself
+            }
+          } else {
+            const targetRoot = getTargetRoot();
+            targetEl = targetRoot ? targetRoot.querySelector(selector) : null;
+          }
+
+          if (targetEl) {
+            const isShadowRoot = targetEl instanceof ShadowRoot;
+            const nodes = normalizeNodes(res, currentDoc);
+
+            if (pos === 'replace') {
+              // ShadowRoot doesn't support replaceWith
+              if (!isShadowRoot) {
+                targetEl.replaceWith(...nodes);
+              }
+            } else if (pos === 'replaceChildren') {
+              // Replace all children of target element
+              targetEl.replaceChildren(...nodes);
+            } else if (pos === 'innerHtml') {
+              // Set innerHTML
+              targetEl.innerHTML = res !== undefined && res !== null ? String(res) : '';
+            } else if (pos === 'innerText') {
+              // Set innerText
+              if (targetEl.innerText !== undefined) {
+                targetEl.innerText = res !== undefined && res !== null ? String(res) : '';
+              }
+            } else {
+              /*
+                    <!-- beforebegin -->
+                    <p>
+                      <!-- afterbegin -->
+                      foo
+                      <!-- beforeend -->
+                    </p>
+                    <!-- afterend -->
+               */
+              if (pos === 'beforeEnd') targetEl.append(...nodes);
+              else if (pos === 'afterBegin') targetEl.prepend(...nodes);
+              else if (pos === 'beforeBegin' && !isShadowRoot) targetEl.before(...nodes);
+              else if (pos === 'afterEnd' && !isShadowRoot) targetEl.after(...nodes);
+            }
+          }
+        }
+      }
+      return res;
+    };
+  };
+}
+
+export const findAllApplyNodeMetadata = (target: any): Map<string | symbol, ApplyNodeMetadata> => {
+  const result = new Map<string | symbol, ApplyNodeMetadata>();
+  const maps = ReflectUtils.findAllMetadata<Map<string | symbol, ApplyNodeMetadata>>(APPLY_NODE_METADATA_KEY, target);
+  maps.forEach(map => {
+    if (map instanceof Map) {
+      map.forEach((v, k) => result.set(k, v));
+    }
+  });
+  return result;
+};
+
+/**
+ * @applyNodeHost decorator - simplified version of @applyNode for :host selector
+ * Usage: @applyNodeHost() addItem() { return '<li>New Item</li>'; }
+ * Usage: @applyNodeHost({ position: 'afterBegin' }) prependItem() { return '<h1>Title</h1>'; }
+ */
+export function applyNodeHost(options: ApplyNodeOptions = { position: 'beforeEnd' }): MethodDecorator {
+  return applyNode(':host', options);
+}
+
+// Convenience decorators for specific positions
+
+/**
+ * @applyBeforeBeginNode - Insert before target element
+ */
+export const applyBeforeBeginNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'beforeBegin' });
+
+/**
+ * @applyAfterBeginNode - Prepend to target element
+ */
+export const applyAfterBeginNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'afterBegin' });
+
+/**
+ * @applyBeforeEndNode - Append to target element (default)
+ */
+export const applyBeforeEndNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'beforeEnd' });
+
+/**
+ * @applyAfterEndNode - Insert after target element
+ */
+export const applyAfterEndNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'afterEnd' });
+
+/**
+ * @applyReplaceNode - Replace entire target element
+ */
+export const applyReplaceNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'replace' });
+
+/**
+ * @applyReplaceChildrenNode - Replace all children of target element
+ */
+export const applyReplaceChildrenNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'replaceChildren' });
+
+/**
+ * @applyInnerHtmlNode - Set target's innerHTML
+ */
+export const applyInnerHtmlNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'innerHtml' });
+
+/**
+ * @applyInnerTextNode - Set target's innerText
+ */
+export const applyInnerTextNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'innerText' });
+
+/**
+ * @applyRemoveNode - Remove target element if truthy
+ */
+export const applyRemoveNode = (selector: string, options: ApplyNodeOptions = {}) => 
+  applyNode(selector, { ...options, position: 'remove' });
+
+// Host versions
+
+/**
+ * @applyBeforeBeginNodeHost - Insert before :host
+ */
+export const applyBeforeBeginNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'beforeBegin' });
+
+/**
+ * @applyAfterBeginNodeHost - Prepend to :host
+ */
+export const applyAfterBeginNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'afterBegin' });
+
+/**
+ * @applyBeforeEndNodeHost - Append to :host
+ */
+export const applyBeforeEndNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'beforeEnd' });
+
+/**
+ * @applyAfterEndNodeHost - Insert after :host
+ */
+export const applyAfterEndNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'afterEnd' });
+
+/**
+ * @applyReplaceNodeHost - Replace :host
+ */
+export const applyReplaceNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'replace' });
+
+/**
+ * @applyReplaceChildrenNodeHost - Replace children of :host
+ */
+export const applyReplaceChildrenNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'replaceChildren' });
+
+/**
+ * @applyInnerHtmlNodeHost - Set :host innerHTML
+ */
+export const applyInnerHtmlNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'innerHtml' });
+
+/**
+ * @applyInnerTextNodeHost - Set :host innerText
+ */
+export const applyInnerTextNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'innerText' });
+
+/**
+ * @applyRemoveNodeHost - Remove :host if truthy
+ */
+export const applyRemoveNodeHost = (options: ApplyNodeOptions = {}) => 
+  applyNode(':host', { ...options, position: 'remove' });

package/src/decorators/attribute.ts

@@ -99,6 +99,22 @@ export function attribute(selector: string, options: AttributeOptions = {}): Pro
     }
     metaList.push({ propertyKey, selector, options, privateKey });
 
+    // Helper function to apply setAttribute to targets
+    const applySetAttribute = (inst: any, targets: HTMLElement[], attrName: string, nv: any) => {
+      targets.forEach(it => {
+        console.log('----->', it)
+        if (it && typeof (it as any).setAttribute === 'function') {
+          if (nv === null) {
+            (it as any).removeAttribute(attrName);
+          } else {
+            (it as any).setAttribute(attrName, String(nv));
+          }
+        } else {
+          inst[privateKey] = nv;
+        }
+      });
+    };
+
     Object.defineProperty(target, propertyKey, {
       get(this: any) {
         const attrName = options.name || String(propertyKey);
@@ -127,25 +143,34 @@ export function attribute(selector: string, options: AttributeOptions = {}): Pro
       },
       set(this: any, nv: any) {
         const targetType = options.type || designType;
-        // const convertedValue = convertValue(nv, targetType);
-        // console.log('---set', propertyKey, targetType, nv, convertedValue);
+        // console.log('---set', propertyKey, targetType, nv, this, this.__swc_syncing_init);
 
         const attrName = options.name || String(propertyKey);
         const conf = getElementConfig(this);
         const currentWin = this._resolveWindow?.(conf) || ((typeof window !== 'undefined' ? window : undefined) as any);
-        const targets = resolveTargetEls(this, selector, options, currentWin);
-        targets.forEach(it => {
-          console.log('----->', it)
-          if (it && typeof (it as any).setAttribute === 'function') {
-            if (nv === null) {
-              (it as any).removeAttribute(attrName);
-            } else {
-              (it as any).setAttribute(attrName, String(nv));
-            }
+
+        // During initialization/syncing phase
+        if (this.__swc_syncing_init) {
+          // If connectedInitialize is enabled, force setAttribute (JS -> DOM)
+          if (options.connectedInitialize === true) {
+            const targets = resolveTargetEls(this, selector, options, currentWin);
+            applySetAttribute(this, targets, attrName, nv);
           } else {
+            // Otherwise just update memory
             this[privateKey] = nv;
           }
-        })
+          return;
+        }
+
+        // Before connected, save to memory only
+        if (!this.__swc_connected) {
+          this[privateKey] = nv;
+          return;
+        }
+
+        // After connected, normal setAttribute
+        const targets = resolveTargetEls(this, selector, options, currentWin);
+        applySetAttribute(this, targets, attrName, nv);
       },
       enumerable: true,
       configurable: true
@@ -156,3 +181,12 @@ export function attribute(selector: string, options: AttributeOptions = {}): Pro
 export const findAllAttributeMetadata = (target: any): AttributeMetadata[] => {
   return ReflectUtils.findAllMetadata<AttributeMetadata[]>(ATTRIBUTE_METADATA_KEY, target).flat();
 };
+
+/**
+ * @hostAttribute decorator - simplified version of @attribute for :host selector
+ * Usage: @hostAttribute('data-product-id')
+ * Usage: @hostAttribute('disabled', { type: Boolean })
+ */
+export function attributeHost(attrName: string, options: AttributeOptions = {}): PropertyDecorator {
+  return attribute(':host', { ...options, name: attrName });
+}

package/src/decorators/{changedAttribute.ts → changedAttributeHost.ts}

@@ -2,7 +2,11 @@ import { ReflectUtils } from '@dooboostore/core';
 
 export const ON_ATTRIBUTE_CHANGED_METADATA_KEY = Symbol('simple-web-component:on-attribute-changed');
 
-export function changedAttribute(attributeName?: string): MethodDecorator {
+/**
+ * @changedAttributeHost decorator - fires when any attribute on :host changes
+ * Usage: @changedAttributeHost('data-product-id')
+ */
+export function changedAttributeHost(attributeName?: string): MethodDecorator {
   return (target: Object, propertyKey: string | symbol) => {
     const constructor = target.constructor;
     let meta = ReflectUtils.getOwnMetadata(ON_ATTRIBUTE_CHANGED_METADATA_KEY, constructor) as Map<string, (string | symbol)[]>;

package/src/decorators/classList.ts

@@ -1,6 +1,7 @@
 import { ReflectUtils } from '@dooboostore/core';
 import { ensureInit } from './elementDefine';
 import { SwcUtils } from '../utils/Utils';
+import { SwcQueryOptions } from '../types';
 
 export const CLASS_LIST_METADATA_KEY = Symbol('simple-web-component:class-list');
 
@@ -10,10 +11,11 @@ export interface ClassListMetadata {
   propertyKey: string | symbol;
   selector: string;
   action: ClassListAction;
+  options: SwcQueryOptions;
 }
 
 function createClassListDecorator(action: ClassListAction) {
-  return (selector: string): MethodDecorator => {
+  return (selector: string, options: SwcQueryOptions = {}): MethodDecorator => {
     return (target: Object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
       const constructor = target.constructor;
       let metaList = ReflectUtils.getOwnMetadata(CLASS_LIST_METADATA_KEY, constructor) as Map<string | symbol, ClassListMetadata>;
@@ -21,22 +23,43 @@ function createClassListDecorator(action: ClassListAction) {
         metaList = new Map<string | symbol, ClassListMetadata>();
         ReflectUtils.defineMetadata(CLASS_LIST_METADATA_KEY, metaList, constructor);
       }
-      metaList.set(propertyKey, { propertyKey, selector, action });
+      metaList.set(propertyKey, { propertyKey, selector, action, options });
 
       const original = descriptor.value;
       descriptor.value = async function (...args: any[]) {
         ensureInit(this);
         const res = await original.apply(this, args);
         if (res !== undefined) {
+          const r = options.root || 'auto';
           const hostSet = SwcUtils.getHostSet(this as any);
+          const targetEls: HTMLElement[] = [];
 
-          let targetEl: HTMLElement | null = null;
-          if (selector === ':host' || !selector) targetEl = this as any;
-          else if (selector === ':parentHost') targetEl = hostSet.$parentHost;
-          else if (selector === ':appHost') targetEl = hostSet.$appHost;
-          else targetEl = (this.shadowRoot || (this as any)).querySelector(selector);
+          if (selector === ':host' || !selector) {
+            targetEls.push(this as any);
+          } else if (selector === ':parentHost') {
+            if (hostSet.$parentHost) targetEls.push(hostSet.$parentHost);
+          } else if (selector === ':appHost') {
+            if (hostSet.$appHost) targetEls.push(hostSet.$appHost);
+          } else {
+            if (r === 'shadow') {
+              const found = this.shadowRoot?.querySelectorAll(selector);
+              if (found) targetEls.push(...found);
+            } else if (r === 'light') {
+              const found = (this as any).querySelectorAll(selector);
+              if (found) targetEls.push(...found);
+            } else if (r === 'all') {
+              const sFound = this.shadowRoot?.querySelectorAll(selector);
+              const lFound = (this as any).querySelectorAll(selector);
+              if (sFound) targetEls.push(...sFound);
+              if (lFound) targetEls.push(...lFound);
+            } else {
+              // auto
+              const found = (this.shadowRoot || (this as any)).querySelectorAll(selector);
+              if (found) targetEls.push(...found);
+            }
+          }
 
-          if (targetEl) {
+          targetEls.forEach(targetEl => {
             if (action === 'set') {
               let classes = '';
               if (typeof res === 'object' && res !== null && !Array.isArray(res)) {
@@ -51,7 +74,7 @@ function createClassListDecorator(action: ClassListAction) {
             } else if (action === 'update') {
               if (typeof res === 'object' && res !== null && !Array.isArray(res)) {
                 Object.entries(res).forEach(([cls, force]) => {
-                  targetEl!.classList.toggle(cls, !!force);
+                  targetEl.classList.toggle(cls, !!force);
                 });
               } else if (res !== undefined && res !== null) {
                 const classes = Array.isArray(res) ? res.map(String) : [String(res)];
@@ -65,9 +88,9 @@ function createClassListDecorator(action: ClassListAction) {
               targetEl.classList.remove(...classes);
             } else if (action === 'toggle') {
               const classes = Array.isArray(res) ? res.map(String) : [String(res)];
-              classes.forEach(c => targetEl!.classList.toggle(c));
+              classes.forEach(c => targetEl.classList.toggle(c));
             }
-          }
+          });
         }
         return res;
       };
@@ -79,31 +102,63 @@ function createClassListDecorator(action: ClassListAction) {
  * @setClassList decorator to surgically replace all classes on a target element.
  * Returns: string | string[]
  */
-export const setClassList = createClassListDecorator('set');
+export const setClassList = (selector: string, options: SwcQueryOptions = {}) => createClassListDecorator('set')(selector, options);
 
 /**
  * @updateClassList decorator to surgically update specific classes.
  * Returns: Record<string, boolean> (toggle with force) | string | string[] (add)
  */
-export const updateClassList = createClassListDecorator('update');
+export const updateClassList = (selector: string, options: SwcQueryOptions = {}) => createClassListDecorator('update')(selector, options);
 
 /**
  * @addClassList decorator to surgically add classes to a target element.
  * Returns: string | string[]
  */
-export const addClassList = createClassListDecorator('add');
+export const addClassList = (selector: string, options: SwcQueryOptions = {}) => createClassListDecorator('add')(selector, options);
 
 /**
  * @removeClassList decorator to surgically remove classes from a target element.
  * Returns: string | string[]
  */
-export const removeClassList = createClassListDecorator('remove');
+export const removeClassList = (selector: string, options: SwcQueryOptions = {}) => createClassListDecorator('remove')(selector, options);
 
 /**
  * @toggleClassList decorator to surgically toggle classes on a target element.
  * Returns: string | string[]
  */
-export const toggleClassList = createClassListDecorator('toggle');
+export const toggleClassList = (selector: string, options: SwcQueryOptions = {}) => createClassListDecorator('toggle')(selector, options);
+
+// Host-specific versions (for :host selector)
+
+/**
+ * @setClassListHost decorator to set classes on :host element.
+ * Returns: string | string[]
+ */
+export const setClassListHost = (options: SwcQueryOptions = {}) => createClassListDecorator('set')(':host', options);
+
+/**
+ * @updateClassListHost decorator to update specific classes on :host.
+ * Returns: Record<string, boolean> (toggle with force) | string | string[] (add)
+ */
+export const updateClassListHost = (options: SwcQueryOptions = {}) => createClassListDecorator('update')(':host', options);
+
+/**
+ * @addClassListHost decorator to add classes to :host element.
+ * Returns: string | string[]
+ */
+export const addClassListHost = (options: SwcQueryOptions = {}) => createClassListDecorator('add')(':host', options);
+
+/**
+ * @removeClassListHost decorator to remove classes from :host element.
+ * Returns: string | string[]
+ */
+export const removeClassListHost = (options: SwcQueryOptions = {}) => createClassListDecorator('remove')(':host', options);
+
+/**
+ * @toggleClassListHost decorator to toggle classes on :host element.
+ * Returns: string | string[]
+ */
+export const toggleClassListHost = (options: SwcQueryOptions = {}) => createClassListDecorator('toggle')(':host', options);
 
 export const findAllClassListMetadata = (target: any): Map<string | symbol, ClassListMetadata> => {
   const result = new Map<string | symbol, ClassListMetadata>();