assign-gingerly 0.0.76 → 0.0.78

package/DX/emojis.ts

@@ -22,7 +22,7 @@
  * | 🏷️ | builtIns.microDataJoin |
  * | 📋 | builtIns.manageTemplateList |
  */
-export const builtInEmoji: Record<string, string> = {
+export const builtInEmoji= {
     '📦': 'builtIns.lazyLoad',
     '🎚️': 'builtIns.lazyLoadSwitch',
     '🔗': 'builtIns.join',
@@ -31,7 +31,7 @@ export const builtInEmoji: Record<string, string> = {
     '📊': 'builtIns.rangeSelector',
 };
 
-export const akaMethods: Record<string, string> = {
+export const akaMethods = {
     '🔍': 'querySelector',
     '🧺': 'querySelectorAll',
     '+': 'add',
@@ -53,7 +53,7 @@ export const akaMethods: Record<string, string> = {
     //'🧩': 'includes'
 };
 
-export const aka: Record<string, string> = {
+export const aka = {
     '©️': 'content?.cloneNode?.true',
     //'🔎': 'clone?.querySelector'
     // textContent is a property, not a method — aliasing it via akaMethods

package/assignFeatures.js

@@ -84,10 +84,8 @@ function isAsyncResolution(spawnish) {
 }
 /**
  * Resolves all configured spawns for the target constructor and caches them.
- * Returns a Promise if any resolution is async, otherwise undefined.
  */
-function resolveAndCacheSpawns(ctr, features, supportedFeatures) {
-    let hasAsync = false;
+async function resolveAndCacheSpawns(ctr, features, supportedFeatures) {
     const asyncResolutions = [];
     for (const key of Object.keys(features)) {
         const classCache = getOrCreateClassCache(ctr);
@@ -104,7 +102,6 @@ function resolveAndCacheSpawns(ctr, features, supportedFeatures) {
             continue;
         }
         if (isAsyncResolution(spawnish)) {
-            hasAsync = true;
             asyncResolutions.push((async () => {
                 const resolved = await resolveSpawn(spawnish);
                 classCache.set(key, resolved);
@@ -114,10 +111,9 @@ function resolveAndCacheSpawns(ctr, features, supportedFeatures) {
             classCache.set(key, spawnish);
         }
     }
-    if (hasAsync) {
-        return Promise.all(asyncResolutions).then(() => undefined);
+    if (asyncResolutions.length > 0) {
+        await Promise.all(asyncResolutions);
     }
-    return undefined;
 }
 /**
  * Installs a getter/setter pair on the constructor's prototype for the given feature key.
@@ -288,7 +284,7 @@ function installCallbackForwarding(ctr, key, callbacks) {
         featureKeys.add(key);
     }
 }
-function installOneFeature(ctr, key, features, supportedFeatures, featuresRegistry) {
+async function installOneFeature(ctr, key, features, supportedFeatures, featuresRegistry) {
     // 1. Confirm the key is opted-in via supportedFeatures
     if (!(key in supportedFeatures)) {
         throw new Error(`assignFeatures: "${key}" is not declared in ${ctr.name || 'constructor'}.supportedFeatures`);
@@ -322,27 +318,13 @@ function installOneFeature(ctr, key, features, supportedFeatures, featuresRegist
     if (resolvedSpawn && !isAsyncSpawn(resolvedSpawn) &&
         Object.hasOwn(resolvedSpawn, 'onAssigned') &&
         typeof resolvedSpawn.onAssigned === 'function') {
-        const result = resolvedSpawn.onAssigned(ctr, featureConfig, key);
-        if (result && typeof result.then === 'function') {
-            return result;
-        }
+        await resolvedSpawn.onAssigned(ctr, featureConfig, key);
     }
-    return undefined;
 }
-function installAllFeatures(ctr, features, supportedFeatures, featuresRegistry) {
-    let asyncResult;
+async function installAllFeatures(ctr, features, supportedFeatures, featuresRegistry) {
     for (const key of Object.keys(features)) {
-        const result = installOneFeature(ctr, key, features, supportedFeatures, featuresRegistry);
-        if (result) {
-            if (!asyncResult) {
-                asyncResult = result.then(() => undefined);
-            }
-            else {
-                asyncResult = asyncResult.then(() => result.then(() => undefined));
-            }
-        }
+        await installOneFeature(ctr, key, features, supportedFeatures, featuresRegistry);
     }
-    return asyncResult;
 }
 /**
  * Core assignFeatures implementation.
@@ -357,7 +339,7 @@ function installAllFeatures(ctr, features, supportedFeatures, featuresRegistry)
  * @param features - Map of feature keys to their injection configs
  * @param featuresRegistry - The registry to store injections in
  */
-export function assignFeatures(ctr, features, featuresRegistry) {
+export async function assignFeatures(ctr, features, featuresRegistry) {
     // Validate that the constructor has static supportedFeatures
     const supportedFeatures = ctr.supportedFeatures;
     if (!supportedFeatures) {
@@ -366,11 +348,8 @@ export function assignFeatures(ctr, features, featuresRegistry) {
     // Resolve all configured spawns before installing getters. This is the single
     // source of truth for spawn resolution; other callers (defineWithFeatures, etc.)
     // delegate to assignFeatures.
-    const spawnResolution = resolveAndCacheSpawns(ctr, features, supportedFeatures);
-    if (spawnResolution) {
-        return spawnResolution.then(() => installAllFeatures(ctr, features, supportedFeatures, featuresRegistry));
-    }
-    return installAllFeatures(ctr, features, supportedFeatures, featuresRegistry);
+    await resolveAndCacheSpawns(ctr, features, supportedFeatures);
+    await installAllFeatures(ctr, features, supportedFeatures, featuresRegistry);
 }
 /**
  * Captures own-properties that shadow feature getters and stores them as initVals.

package/assignFeatures.ts

@@ -96,14 +96,12 @@ function isAsyncResolution(spawnish: any): boolean {
 
 /**
  * Resolves all configured spawns for the target constructor and caches them.
- * Returns a Promise if any resolution is async, otherwise undefined.
  */
-function resolveAndCacheSpawns(
+async function resolveAndCacheSpawns(
     ctr: Function,
     features: FeatureConfigsMap,
     supportedFeatures: SupportedFeaturesMap
-): Promise<void> | undefined {
-    let hasAsync = false;
+): Promise<void> {
     const asyncResolutions: Promise<void>[] = [];
 
     for (const key of Object.keys(features)) {
@@ -123,7 +121,6 @@ function resolveAndCacheSpawns(
         }
 
         if (isAsyncResolution(spawnish)) {
-            hasAsync = true;
             asyncResolutions.push((async () => {
                 const resolved = await resolveSpawn(spawnish);
                 classCache.set(key, resolved);
@@ -133,10 +130,9 @@ function resolveAndCacheSpawns(
         }
     }
 
-    if (hasAsync) {
-        return Promise.all(asyncResolutions).then(() => undefined);
+    if (asyncResolutions.length > 0) {
+        await Promise.all(asyncResolutions);
     }
-    return undefined;
 }
 
 /**
@@ -349,13 +345,13 @@ function installCallbackForwarding(
     }
 }
 
-function installOneFeature(
+async function installOneFeature(
     ctr: Function,
     key: string,
     features: FeatureConfigsMap,
     supportedFeatures: SupportedFeaturesMap,
     featuresRegistry: FeaturesRegistry
-): Promise<void> | undefined {
+): Promise<void> {
     // 1. Confirm the key is opted-in via supportedFeatures
     if (!(key in supportedFeatures)) {
         throw new Error(
@@ -401,32 +397,19 @@ function installOneFeature(
     if (resolvedSpawn && !isAsyncSpawn(resolvedSpawn) &&
         Object.hasOwn(resolvedSpawn, 'onAssigned') &&
         typeof (resolvedSpawn as any).onAssigned === 'function') {
-        const result = (resolvedSpawn as any).onAssigned(ctr, featureConfig, key);
-        if (result && typeof result.then === 'function') {
-            return result;
-        }
+        await (resolvedSpawn as any).onAssigned(ctr, featureConfig, key);
     }
-    return undefined;
 }
 
-function installAllFeatures(
+async function installAllFeatures(
     ctr: Function,
     features: FeatureConfigsMap,
     supportedFeatures: SupportedFeaturesMap,
     featuresRegistry: FeaturesRegistry
-): Promise<void> | undefined {
-    let asyncResult: Promise<void> | undefined;
+): Promise<void> {
     for (const key of Object.keys(features)) {
-        const result = installOneFeature(ctr, key, features, supportedFeatures, featuresRegistry);
-        if (result) {
-            if (!asyncResult) {
-                asyncResult = result.then(() => undefined);
-            } else {
-                asyncResult = asyncResult.then(() => result.then(() => undefined));
-            }
-        }
+        await installOneFeature(ctr, key, features, supportedFeatures, featuresRegistry);
     }
-    return asyncResult;
 }
 
 /**
@@ -442,11 +425,11 @@ function installAllFeatures(
  * @param features - Map of feature keys to their injection configs
  * @param featuresRegistry - The registry to store injections in
  */
-export function assignFeatures(
+export async function assignFeatures(
     ctr: Function,
     features: FeatureConfigsMap,
     featuresRegistry: FeaturesRegistry
-): Promise<void> | undefined {
+): Promise<void> {
     // Validate that the constructor has static supportedFeatures
     const supportedFeatures: SupportedFeaturesMap | undefined = (ctr as any).supportedFeatures;
 
@@ -459,15 +442,8 @@ export function assignFeatures(
     // Resolve all configured spawns before installing getters. This is the single
     // source of truth for spawn resolution; other callers (defineWithFeatures, etc.)
     // delegate to assignFeatures.
-    const spawnResolution = resolveAndCacheSpawns(ctr, features, supportedFeatures);
-
-    if (spawnResolution) {
-        return spawnResolution.then(() =>
-            installAllFeatures(ctr, features, supportedFeatures, featuresRegistry)
-        );
-    }
-
-    return installAllFeatures(ctr, features, supportedFeatures, featuresRegistry);
+    await resolveAndCacheSpawns(ctr, features, supportedFeatures);
+    await installAllFeatures(ctr, features, supportedFeatures, featuresRegistry);
 }
 
 /**
@@ -682,7 +658,7 @@ export class PropertyBag {
 declare global {
     interface CustomElementRegistry {
         featuresRegistry: FeaturesRegistry;
-        assignFeatures(ctr: Function, features: FeatureConfigsMap): Promise<void> | undefined;
+        assignFeatures(ctr: Function, features: FeatureConfigsMap): Promise<void>;
     }
 }
 

package/assignGingerly.js

@@ -1,4 +1,5 @@
 import { normalizeAliasOptions } from './resolve/getValues.js';
+const DEFAULT_ENHANCEMENT_KEY = Symbol('assign-gingerly.default-enhancement-setup');
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions
  */
@@ -34,6 +35,7 @@ export class EnhancementRegisteredEvent extends Event {
  */
 export class EnhancementRegistry extends EventTarget {
     #items = new Set();
+    #pendingSetups = new Map();
     push(items) {
         if (Array.isArray(items)) {
             items.forEach(item => this.#items.add(item));
@@ -43,11 +45,12 @@ export class EnhancementRegistry extends EventTarget {
         }
         // Dispatch event after adding items
         this.dispatchEvent(new EnhancementRegisteredEvent(items));
-        // Process features if present (fire-and-forget, uses shared featuresRegistry)
+        // Process features if present (async, tracked so callers can await)
         const itemsArr = Array.isArray(items) ? items : [items];
         for (const item of itemsArr) {
             if (item.features) {
-                this.#assignFeatures(item.spawn, item.features);
+                const promise = this.#assignFeatures(item.spawn, item.features);
+                this._trackSetup(item.enhKey ?? DEFAULT_ENHANCEMENT_KEY, promise);
             }
         }
     }
@@ -56,8 +59,39 @@ export class EnhancementRegistry extends EventTarget {
         const featuresRegistry = this._featuresRegistry
             ?? (typeof customElements !== 'undefined' ? customElements.featuresRegistry : undefined);
         if (featuresRegistry) {
-            assignFeatures(spawn, features, featuresRegistry);
+            await assignFeatures(spawn, features, featuresRegistry);
+        }
+    }
+    /**
+     * Wait for all pending setups for a given enhancement key to complete.
+     * @param enhKey - Enhancement key to wait for
+     */
+    async whenDefined(enhKey) {
+        const pending = this.#pendingSetups.get(enhKey);
+        if (pending && pending.length > 0) {
+            await Promise.all(pending);
+        }
+    }
+    /**
+     * Internal method to track a pending setup.
+     * @param name - Setup key
+     * @param promise - Promise representing the setup operation
+     */
+    _trackSetup(name, promise) {
+        if (!this.#pendingSetups.has(name)) {
+            this.#pendingSetups.set(name, []);
         }
+        this.#pendingSetups.get(name).push(promise);
+        // Clean up after completion
+        promise.finally(() => {
+            const pending = this.#pendingSetups.get(name);
+            if (pending) {
+                const index = pending.indexOf(promise);
+                if (index > -1) {
+                    pending.splice(index, 1);
+                }
+            }
+        });
     }
     getItems() {
         return Array.from(this.#items);
@@ -105,9 +139,10 @@ export class ItemscopeRegistry extends EventTarget {
         }
         this.#configs.set(name, config);
         this.dispatchEvent(new Event(name));
-        // Process features if present (fire-and-forget, uses shared featuresRegistry)
+        // Process features if present (async, tracked so callers can await)
         if (config.features) {
-            this.#assignFeatures(config.manager, config.features);
+            const promise = this.#assignFeatures(config.manager, config.features);
+            this._trackSetup(name, promise);
         }
     }
     async #assignFeatures(manager, features) {
@@ -115,7 +150,7 @@ export class ItemscopeRegistry extends EventTarget {
         const featuresRegistry = this._featuresRegistry
             ?? (typeof customElements !== 'undefined' ? customElements.featuresRegistry : undefined);
         if (featuresRegistry) {
-            assignFeatures(manager, features, featuresRegistry);
+            await assignFeatures(manager, features, featuresRegistry);
         }
     }
     /**

package/assignGingerly.ts

@@ -1,10 +1,12 @@
 
 
-import { EnhancementConfig } from "./types/assign-gingerly/types";
+import { EnhancementConfig, EnhKey } from "./types/assign-gingerly/types";
 import type { AssignFromOptions, FeatureConfigsMap, IAssignGingerlyOptions } from "./types/assign-gingerly/types";
 import type { PermissionProcessor } from './types/assign-gingerly/types.js';
 import { normalizeAliasOptions } from './resolve/getValues.js';
 
+const DEFAULT_ENHANCEMENT_KEY = Symbol('assign-gingerly.default-enhancement-setup');
+
 /**
  * Constructor signature for ItemScope Manager classes
  */
@@ -72,6 +74,7 @@ export class EnhancementRegisteredEvent extends Event {
  */
 export class EnhancementRegistry extends EventTarget {
   #items: Set<EnhancementConfig> = new Set();
+  #pendingSetups = new Map<EnhKey, Promise<void>[]>();
 
   push(items: EnhancementConfig | EnhancementConfig[]): void {
     if (Array.isArray(items)) {
@@ -83,11 +86,12 @@ export class EnhancementRegistry extends EventTarget {
     // Dispatch event after adding items
     this.dispatchEvent(new EnhancementRegisteredEvent(items));
 
-    // Process features if present (fire-and-forget, uses shared featuresRegistry)
+    // Process features if present (async, tracked so callers can await)
     const itemsArr = Array.isArray(items) ? items : [items];
     for (const item of itemsArr) {
       if (item.features) {
-        this.#assignFeatures(item.spawn, item.features);
+        const promise = this.#assignFeatures(item.spawn, item.features);
+        this._trackSetup(item.enhKey ?? DEFAULT_ENHANCEMENT_KEY, promise);
       }
     }
   }
@@ -97,8 +101,42 @@ export class EnhancementRegistry extends EventTarget {
     const featuresRegistry = (this as any)._featuresRegistry
       ?? (typeof customElements !== 'undefined' ? (customElements as any).featuresRegistry : undefined);
     if (featuresRegistry) {
-      assignFeatures(spawn, features, featuresRegistry);
+      await assignFeatures(spawn, features, featuresRegistry);
+    }
+  }
+
+  /**
+   * Wait for all pending setups for a given enhancement key to complete.
+   * @param enhKey - Enhancement key to wait for
+   */
+  async whenDefined(enhKey: EnhKey): Promise<void> {
+    const pending = this.#pendingSetups.get(enhKey);
+    if (pending && pending.length > 0) {
+      await Promise.all(pending);
+    }
+  }
+
+  /**
+   * Internal method to track a pending setup.
+   * @param name - Setup key
+   * @param promise - Promise representing the setup operation
+   */
+  _trackSetup(name: EnhKey, promise: Promise<void>): void {
+    if (!this.#pendingSetups.has(name)) {
+      this.#pendingSetups.set(name, []);
     }
+    this.#pendingSetups.get(name)!.push(promise);
+
+    // Clean up after completion
+    promise.finally(() => {
+      const pending = this.#pendingSetups.get(name);
+      if (pending) {
+        const index = pending.indexOf(promise);
+        if (index > -1) {
+          pending.splice(index, 1);
+        }
+      }
+    });
   }
 
   getItems(): EnhancementConfig[] {
@@ -151,9 +189,10 @@ export class ItemscopeRegistry extends EventTarget {
     this.#configs.set(name, config);
     this.dispatchEvent(new Event(name));
 
-    // Process features if present (fire-and-forget, uses shared featuresRegistry)
+    // Process features if present (async, tracked so callers can await)
     if ((config as any).features) {
-      this.#assignFeatures(config.manager, (config as any).features);
+      const promise = this.#assignFeatures(config.manager, (config as any).features);
+      this._trackSetup(name, promise);
     }
   }
 
@@ -162,7 +201,7 @@ export class ItemscopeRegistry extends EventTarget {
     const featuresRegistry = (this as any)._featuresRegistry
       ?? (typeof customElements !== 'undefined' ? (customElements as any).featuresRegistry : undefined);
     if (featuresRegistry) {
-      assignFeatures(manager, features, featuresRegistry);
+      await assignFeatures(manager, features, featuresRegistry);
     }
   }
 

package/inferencer/types/assign-gingerly/types.d.ts

@@ -484,6 +484,8 @@ export declare class EnhancementRegistry extends EventTarget {
   getItems(): EnhancementConfig[];
   findBySymbol(symbol: symbol | string): EnhancementConfig | undefined;
   findByEnhKey(enhKey: string | symbol): EnhancementConfig | undefined;
+  whenDefined(enhKey: string | symbol): Promise<void>;
+  _trackSetup(name: string | symbol, promise: Promise<void>): void;
 }
 
 /**
@@ -652,7 +654,7 @@ export declare function assignFeatures(
     ctr: Function,
     features: FeatureConfigsMap,
     featuresRegistry: FeaturesRegistry
-): Promise<void> | undefined;
+): Promise<void>;
 
 /**
  * Captures own-properties that shadow feature getters.

package/inferencer/types/wc-info/SimpleWCInfo.d.ts

@@ -0,0 +1,15 @@
+export interface SimpleWCInfo<TProps = any, TPublicMethods = any>{
+    tagName: string;
+    cssParts?: {[key: string]: string};
+    props?: any;
+    methods?: any;
+    nonAttribProps?: (keyof TProps)[];
+    cssProps?: {[key: string]: string};
+    slots?: {[key: string]: string};
+    events?: {[key: string]: string};
+    name: string,
+    description: string,
+    homepage: string,
+    license: string,
+
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.76",
+  "version": "0.0.78",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {

package/types/assign-gingerly/types.d.ts

@@ -484,6 +484,8 @@ export declare class EnhancementRegistry extends EventTarget {
   getItems(): EnhancementConfig[];
   findBySymbol(symbol: symbol | string): EnhancementConfig | undefined;
   findByEnhKey(enhKey: string | symbol): EnhancementConfig | undefined;
+  whenDefined(enhKey: string | symbol): Promise<void>;
+  _trackSetup(name: string | symbol, promise: Promise<void>): void;
 }
 
 /**
@@ -652,7 +654,7 @@ export declare function assignFeatures(
     ctr: Function,
     features: FeatureConfigsMap,
     featuresRegistry: FeaturesRegistry
-): Promise<void> | undefined;
+): Promise<void>;
 
 /**
  * Captures own-properties that shadow feature getters.