assign-gingerly 0.0.73 → 0.0.74

package/resolveAndAssignFeatures.js

@@ -1,12 +1,12 @@
 /**
- * resolveAndAssignFeatures - Resolves async fallback spawns then calls assignFeatures.
+ * resolveAndAssignFeatures - Thin wrapper around assignFeatures for backward compatibility.
  *
- * For each feature in the config that doesn't have an explicit `spawn`, resolves
- * the async `fallbackSpawn` from the class's `static supportedFeatures` and sets
- * it as the spawn. Then calls `assignFeatures` with the fully resolved config.
+ * Resolves all configured spawns (including async fallback spawns and string import paths)
+ * and installs feature getters on the class prototype, then delegates to the registry's
+ * assignFeatures implementation.
  *
- * This eliminates the boilerplate of manually resolving async spawns before
- * calling assignFeatures.
+ * This is kept as a convenience entry point for callers that already await this function.
+ * The actual resolution logic lives in assignFeatures.
  *
  * @example
  * import { resolveAndAssignFeatures } from 'assign-gingerly/resolveAndAssignFeatures.js';
@@ -22,46 +22,15 @@
  *     }
  * });
  */
+import { assignFeatures } from './assignFeatures.js';
 /**
- * Determines if a function is an async spawner.
- */
-function isAsyncSpawn(fn) {
-    if (typeof fn !== 'function')
-        return false;
-    if (fn.constructor.name === 'AsyncFunction')
-        return true;
-    if (fn.prototype === undefined)
-        return true;
-    return false;
-}
-/**
- * Resolves async fallback spawns for features that don't have an explicit spawn,
- * then calls assignFeatures on the registry.
+ * Resolves all configured spawns and calls assignFeatures on the registry.
  *
  * @param ElementClass - The custom element class (must have static supportedFeatures)
  * @param featuresConfig - Feature configurations (spawn will be resolved from fallbackSpawn if missing)
  * @param registry - Optional CustomElementRegistry (defaults to global customElements)
  */
 export async function resolveAndAssignFeatures(ElementClass, featuresConfig, registry) {
-    const supportedFeatures = ElementClass.supportedFeatures;
-    if (!supportedFeatures) {
-        throw new Error(`resolveAndAssignFeatures: ${ElementClass.name || 'constructor'} does not define static supportedFeatures`);
-    }
-    // Resolve async fallback spawns in parallel for features without explicit spawn
-    await Promise.all(Object.entries(featuresConfig).map(async ([key, featureConfig]) => {
-        // Skip if spawn is already provided
-        if (featureConfig.spawn)
-            return;
-        const optIn = supportedFeatures[key];
-        if (!optIn?.fallbackSpawn)
-            return;
-        let spawn = optIn.fallbackSpawn;
-        if (isAsyncSpawn(spawn)) {
-            spawn = await spawn();
-        }
-        featureConfig.spawn = spawn;
-    }));
-    // Call assignFeatures on the registry
     const reg = registry || customElements;
-    await reg.assignFeatures(ElementClass, featuresConfig);
+    await assignFeatures(ElementClass, featuresConfig, reg.featuresRegistry);
 }

package/resolveAndAssignFeatures.ts

@@ -1,79 +1,43 @@
-/**
- * resolveAndAssignFeatures - Resolves async fallback spawns then calls assignFeatures.
- * 
- * For each feature in the config that doesn't have an explicit `spawn`, resolves
- * the async `fallbackSpawn` from the class's `static supportedFeatures` and sets
- * it as the spawn. Then calls `assignFeatures` with the fully resolved config.
- * 
- * This eliminates the boilerplate of manually resolving async spawns before
- * calling assignFeatures.
- * 
- * @example
- * import { resolveAndAssignFeatures } from 'assign-gingerly/resolveAndAssignFeatures.js';
- * 
- * await resolveAndAssignFeatures(MyElement, {
- *     roundabout: {
- *         customData: {...},
- *         withAttrs: {...},
- *         callbackForwarding: ['connectedCallback']
- *     },
- *     faceUp: {
- *         callbackForwarding: ['connectedCallback', 'disconnectedCallback']
- *     }
- * });
- */
-
-import { FeatureConfigsMap, SupportedFeaturesMap } from './types/assign-gingerly/types.js';
-
-/**
- * Determines if a function is an async spawner.
- */
-function isAsyncSpawn(fn: any): boolean {
-    if (typeof fn !== 'function') return false;
-    if (fn.constructor.name === 'AsyncFunction') return true;
-    if (fn.prototype === undefined) return true;
-    return false;
-}
-
-/**
- * Resolves async fallback spawns for features that don't have an explicit spawn,
- * then calls assignFeatures on the registry.
- * 
- * @param ElementClass - The custom element class (must have static supportedFeatures)
- * @param featuresConfig - Feature configurations (spawn will be resolved from fallbackSpawn if missing)
- * @param registry - Optional CustomElementRegistry (defaults to global customElements)
- */
-export async function resolveAndAssignFeatures(
-    ElementClass: Function,
-    featuresConfig: FeatureConfigsMap,
-    registry?: any
-): Promise<void> {
-    const supportedFeatures: SupportedFeaturesMap | undefined = (ElementClass as any).supportedFeatures;
-
-    if (!supportedFeatures) {
-        throw new Error(
-            `resolveAndAssignFeatures: ${(ElementClass as any).name || 'constructor'} does not define static supportedFeatures`
-        );
-    }
-
-    // Resolve async fallback spawns in parallel for features without explicit spawn
-    await Promise.all(
-        Object.entries(featuresConfig).map(async ([key, featureConfig]) => {
-            // Skip if spawn is already provided
-            if (featureConfig.spawn) return;
-
-            const optIn = supportedFeatures[key];
-            if (!optIn?.fallbackSpawn) return;
-
-            let spawn = optIn.fallbackSpawn;
-            if (isAsyncSpawn(spawn)) {
-                spawn = await (spawn as () => Promise<any>)();
-            }
-            (featureConfig as any).spawn = spawn;
-        })
-    );
-
-    // Call assignFeatures on the registry
-    const reg = registry || customElements;
-    await reg.assignFeatures(ElementClass, featuresConfig);
-}
+/**
+ * resolveAndAssignFeatures - Thin wrapper around assignFeatures for backward compatibility.
+ *
+ * Resolves all configured spawns (including async fallback spawns and string import paths)
+ * and installs feature getters on the class prototype, then delegates to the registry's
+ * assignFeatures implementation.
+ *
+ * This is kept as a convenience entry point for callers that already await this function.
+ * The actual resolution logic lives in assignFeatures.
+ *
+ * @example
+ * import { resolveAndAssignFeatures } from 'assign-gingerly/resolveAndAssignFeatures.js';
+ *
+ * await resolveAndAssignFeatures(MyElement, {
+ *     roundabout: {
+ *         customData: {...},
+ *         withAttrs: {...},
+ *         callbackForwarding: ['connectedCallback']
+ *     },
+ *     faceUp: {
+ *         callbackForwarding: ['connectedCallback', 'disconnectedCallback']
+ *     }
+ * });
+ */
+
+import { FeatureConfigsMap } from './types/assign-gingerly/types.js';
+import { assignFeatures } from './assignFeatures.js';
+
+/**
+ * Resolves all configured spawns and calls assignFeatures on the registry.
+ *
+ * @param ElementClass - The custom element class (must have static supportedFeatures)
+ * @param featuresConfig - Feature configurations (spawn will be resolved from fallbackSpawn if missing)
+ * @param registry - Optional CustomElementRegistry (defaults to global customElements)
+ */
+export async function resolveAndAssignFeatures(
+    ElementClass: Function,
+    featuresConfig: FeatureConfigsMap,
+    registry?: any
+): Promise<void> {
+    const reg = registry || customElements;
+    await assignFeatures(ElementClass, featuresConfig, reg.featuresRegistry);
+}

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

@@ -591,21 +591,6 @@ export interface SupportedFeatureConfig {
     callbackForwarding?: string[];
 }
 
-/**
- * Class-level configuration for the features system.
- * Declared as `static featuresConfig` on the class.
- */
-export interface FeaturesClassConfig {
-    /**
-     * Lifecycle method configuration.
-     * true = install 'whenFeatureReady' method.
-     * Object = custom method name.
-     */
-    lifecycleKeys?: true | {
-        whenFeatureReady?: string;
-    };
-}
-
 /**
  * Configuration for a feature passed to assignFeatures.
  */
@@ -615,7 +600,8 @@ export interface FeatureConfig {
      */
     spawn?:
         | { new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }
-        | (() => Promise<{ new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }>);
+        | (() => Promise<{ new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }>)
+        | string // import path or builtIns.* alias
 
     /** Attribute patterns for parsing element attributes into initVals. */
     withAttrs?: AttrPatterns<any>;