assign-gingerly 0.0.72 → 0.0.74

package/enhanceAll.js

@@ -15,7 +15,8 @@
  *     { emc: 'be-observant/emc.json', matching: '[itemprop]' },
  * ]);
  */
-import { isAllowedImportPath } from './isAllowedImportPath.js';
+import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
 /**
  * Apply enhancements in bulk to matching elements within a target.
  *
@@ -37,7 +38,7 @@ export async function enhanceAll(target, configs, permissions) {
         // Validate EMC path unless cross-domain imports are explicitly permitted
         if (!permissions?.crossDomainImports && !isAllowedImportPath(config.emc)) {
             throw new Error(`enhanceAll: EMC path "${config.emc}" is a cross-domain URL. ` +
-                `Only relative, absolute, or bare specifier paths are allowed by default. ` +
+                `Only same-origin paths or import-map-covered specifiers are allowed by default. ` +
                 `Pass { crossDomainImports: true } in permissions to override.`);
         }
         // 1. Import the EMC JSON
@@ -85,13 +86,16 @@ async function resolveAndRegister(enhConfig, target) {
         if (existing)
             return existing;
     }
-    // Not registered — dynamically import the spawn module
+    // Not registered — dynamically import the spawn module and extract the spawn class
     if (!spawnPath)
         return null;
-    const spawnModule = await import(spawnPath);
-    const SpawnClass = spawnModule.default ?? Object.values(spawnModule).find((v) => typeof v === 'function' && v.prototype);
-    if (!SpawnClass)
+    let SpawnClass;
+    try {
+        SpawnClass = await findClassPrototypeInPath(spawnPath);
+    }
+    catch {
         return null;
+    }
     // Build and register the registry item
     const registryItem = {
         spawn: SpawnClass,

package/enhanceAll.ts

@@ -16,8 +16,9 @@
  * ]);
  */
 
-import { isAllowedImportPath } from './isAllowedImportPath.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
+import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
 
 /**
  * Configuration for a single enhancement to apply in bulk.
@@ -57,7 +58,7 @@ export async function enhanceAll(
         if (!permissions?.crossDomainImports && !isAllowedImportPath(config.emc)) {
             throw new Error(
                 `enhanceAll: EMC path "${config.emc}" is a cross-domain URL. ` +
-                `Only relative, absolute, or bare specifier paths are allowed by default. ` +
+                `Only same-origin paths or import-map-covered specifiers are allowed by default. ` +
                 `Pass { crossDomainImports: true } in permissions to override.`
             );
         }
@@ -112,15 +113,15 @@ async function resolveAndRegister(enhConfig: any, target: Element): Promise<any>
         if (existing) return existing;
     }
 
-    // Not registered — dynamically import the spawn module
+    // Not registered — dynamically import the spawn module and extract the spawn class
     if (!spawnPath) return null;
 
-    const spawnModule = await import(spawnPath);
-    const SpawnClass = spawnModule.default ?? Object.values(spawnModule).find(
-        (v: any) => typeof v === 'function' && v.prototype
-    );
-
-    if (!SpawnClass) return null;
+    let SpawnClass;
+    try {
+        SpawnClass = await findClassPrototypeInPath(spawnPath);
+    } catch {
+        return null;
+    }
 
     // Build and register the registry item
     const registryItem: any = {

package/handlers/addEventListener.ts

@@ -9,7 +9,7 @@
 
 import assignGingerly from '../assignGingerly.js';
 import type { AddEventListenerConfig, AssignDispatchVector } from '../types/assign-gingerly/types.js';
-import type { AssignPermissions } from '../isAllowedImportPath.js';
+import type { AssignPermissions } from '../types/assign-gingerly/types.js';
 
 /**
  * WeakMap for dedup: Element → Map<key, AbortController>

package/handlers/lazyLoad.ts

@@ -24,7 +24,7 @@ import type { LazyLoadResolvedParams, LazyLoadInstantiatedContext } from '../typ
 import { withTransition, ensureHideStyle, DEFAULT_HIDE_CLASS } from '../transitionHelper.js';
 import { findMarkers, createMarkers, getNodesBetweenMarkers, findMarkersSibling, createMarkersSibling, MARKER_START_PREFIX, MARKER_END } from '../markerUtils.js';
 import { assignFrom } from '../assignFrom.js';
-import type { AssignPermissions } from '../isAllowedImportPath.js';
+import type { AssignPermissions } from '../types/assign-gingerly/types.js';
 
 export type { LazyLoadResolvedParams, LazyLoadInstantiatedContext };
 

package/handlers/lazyLoadSwitch.ts

@@ -21,7 +21,7 @@
  */
 
 import { LazyLoadHandler } from './lazyLoad.js';
-import type { AssignPermissions } from '../isAllowedImportPath.js';
+import type { AssignPermissions } from '../types/assign-gingerly/types.js';
 import type { AssignFromHandler } from '../assignFromAsync.js';
 import type { LazyLoadSwitchResolvedParams } from '../types/assign-gingerly/types.js';
 

package/handlers/manageTemplateList.ts

@@ -31,7 +31,7 @@ import { findMarkers, createMarkers, getNodesBetweenMarkers, MARKER_START_PREFIX
 import { resolveValue } from '../resolveValues.js';
 import { assignFrom } from '../assignFrom.js';
 import { processInferredAssignments } from '../inferredAssignments.js';
-import type { AssignPermissions } from '../isAllowedImportPath.js';
+import type { AssignPermissions } from '../types/assign-gingerly/types.js';
 
 /**
  * Reserved keys in fromEachItem config — not treated as shorthand patterns.

package/handlers/rangeSelector.ts

@@ -23,7 +23,7 @@
 
 import type { AssignFromHandler } from '../assignFromAsync.js';
 import assignGingerly from '../assignGingerly.js';
-import type { AssignPermissions } from '../isAllowedImportPath.js';
+import type { AssignPermissions } from '../types/assign-gingerly/types.js';
 
 /**
  * Operator keys recognized in case objects.

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

@@ -1,3 +1,5 @@
+import {ParserOptions} from '../nested-regex-groups/types.js';
+
 export type EnhKey = string | symbol;
 
 // type NoUnderscore<T extends string> = T extends `_${string}` ? never : T;
@@ -196,7 +198,7 @@ export interface AttrConfig<T = unknown, TParserConfig = unknown> {
    * For named parsers like 'parse-pattern-statements', this is forwarded
    * as the options argument to the underlying parse function.
    */
-  parserOptions?: any;
+  parserOptions?: ParserOptions;
 }
 
 export type AttrPatterns<T = any> = {
@@ -613,7 +615,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>;

package/inferencer/types/font-face-feature/types.d.ts

@@ -0,0 +1,9 @@
+export interface FontFaceFeatureConfig {
+    fontFamilies: FontFaceConfig | FontFaceConfig[],
+}
+
+export interface FontFaceConfig {
+    name: string,
+    url: string,
+    descriptors: FontFaceDescriptors,
+}

package/inferencer/types/nested-regex-groups/types.d.ts

@@ -91,6 +91,18 @@ export interface ParserOptions {
    * as statement delimiters during splitting.
    */
   ignorePeriodInsideBraces?: boolean;
+
+  /**
+   * When true, normalizes whitespace in the input string before parsing.
+   * This replaces multiple whitespace characters with a single space and trims the string.
+   * Default is false.
+   * 
+   * @example
+   * // Input: "  First.   Second.  "
+   * // With normalizeWhitespace: true -> "First. Second."
+   * // With normalizeWhitespace: false -> "  First.   Second.  "
+   */
+  normalizeWhitespace?: boolean;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.72",
+  "version": "0.0.74",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -18,6 +18,7 @@
     "*.js",
     "*.ts",
     "DX/**",
+    "assignPermissions/**",
     "handlers/**",
     "inferencer/**",
     "README.md",
@@ -143,9 +144,17 @@
       "default": "./enhanceAll.js",
       "types": "./enhanceAll.ts"
     },
-    "./isAllowedImportPath.js": {
-      "default": "./isAllowedImportPath.js",
-      "types": "./isAllowedImportPath.ts"
+    "./assignPermissions/isAllowedImportPath.js": {
+      "default": "./assignPermissions/isAllowedImportPath.js",
+      "types": "./assignPermissions/isAllowedImportPath.ts"
+    },
+    "./utils/findClassPrototypeInPath.js": {
+      "default": "./utils/findClassPrototypeInPath.js",
+      "types": "./utils/findClassPrototypeInPath.ts"
+    },
+    "./utils/isAsyncSpawn.js": {
+      "default": "./utils/isAsyncSpawn.js",
+      "types": "./utils/isAsyncSpawn.ts"
     },
     "./markerUtils.js": {
       "default": "./markerUtils.js",

package/processHandlerCommands.js

@@ -6,7 +6,8 @@
 import { resolveValues } from './resolveValues.js';
 import { getValues } from './getValues.js';
 import { evaluatePathWithMethods } from './assignGingerly.js';
-import { buildRestrictedPropSet, isAllowedImportPath, redirectRestrictedProp } from './isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
+import { buildRestrictedPropSet, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 /**
  * Map of built-in handler names to their module paths.
  * These are auto-loaded on demand — no explicit import required.
@@ -20,23 +21,11 @@ const BUILT_IN_MAP = {
     'builtIns.rangeSelector': './handlers/rangeSelector.js',
 };
 /**
- * Find a handler class in a dynamically imported module.
- * Checks default export first, then searches for the first class with `assign` on prototype.
+ * Criteria for locating an assignFrom handler class: must expose an `assign` method
+ * on its prototype.
  */
-function findHandlerInModule(module) {
-    // Check default export first
-    if (module.default && typeof module.default === 'function'
-        && module.default.prototype && 'assign' in module.default.prototype) {
-        return module.default;
-    }
-    // Search other exports
-    for (const key of Object.keys(module)) {
-        const exported = module[key];
-        if (typeof exported === 'function' && exported.prototype && 'assign' in exported.prototype) {
-            return exported;
-        }
-    }
-    return undefined;
+function handlerCriteria(proto) {
+    return 'assign' in proto.prototype;
 }
 /**
  * Cache for loaded built-in handler classes — avoids await on subsequent calls.
@@ -54,16 +43,14 @@ async function loadBuiltIn(name) {
     const path = BUILT_IN_MAP[name];
     if (!path)
         return undefined;
-    const module = await import(path);
-    const cls = findHandlerInModule(module);
-    if (cls)
-        handlerCache.set(name, cls);
+    const cls = await findClassPrototypeInPath(path, handlerCriteria);
+    handlerCache.set(name, cls);
     return cls;
 }
 /**
  * Resolve a handler from options.handlers (class constructor or import path).
  */
-async function resolveFromHandlers(name, handlers, permissions) {
+async function resolveFromHandlers(name, handlers) {
     if (!handlers || !(name in handlers))
         return undefined;
     const entry = handlers[name];
@@ -77,17 +64,8 @@ async function resolveFromHandlers(name, handlers, permissions) {
         if (entry.startsWith('builtIns.')) {
             return loadBuiltIn(entry);
         }
-        // Import path string — validate and dynamically import
-        if (!permissions?.crossDomainImports && !isAllowedImportPath(entry)) {
-            throw new Error(`assignFrom: handler "${name}" has an invalid import path "${entry}". ` +
-                `Only relative, absolute, or bare specifier paths are allowed (no cross-domain URLs). ` +
-                `Pass { crossDomainImports: true } in permissions to override.`);
-        }
-        const module = await import(entry);
-        const HandlerClass = findHandlerInModule(module);
-        if (!HandlerClass) {
-            throw new Error(`assignFrom: handler "${name}" — module "${entry}" does not export a valid handler class.`);
-        }
+        // Import path string — validate and extract handler class via shared utility
+        const HandlerClass = await findClassPrototypeInPath(entry, handlerCriteria);
         return HandlerClass;
     }
     return undefined;
@@ -179,7 +157,7 @@ export async function processHandlerCommands(target, handlerKeys, pattern, optio
         for (const config of configs) {
             //return; //1.3ms
             // 1. Check options.handlers (local, per-call)
-            let HandlerClass = await resolveFromHandlers(config.do, options.handlers, permissions);
+            let HandlerClass = await resolveFromHandlers(config.do, options.handlers);
             //return; // 1.4
             // 2. Fallback to built-in auto-load
             if (!HandlerClass && config.do.startsWith('builtIns.')) {

package/processHandlerCommands.ts

@@ -7,8 +7,9 @@
 import { resolveValues } from './resolveValues.js';
 import { getValues } from './getValues.js';
 import { evaluatePathWithMethods } from './assignGingerly.js';
-import { buildRestrictedPropSet, isAllowedImportPath, redirectRestrictedProp } from './isAllowedImportPath.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
+import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
+import { buildRestrictedPropSet, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
 import type { AssignFromOptions, AssignFromHandlerConstructor } from './assignFromAsync.js';
 
 /**
@@ -25,23 +26,11 @@ const BUILT_IN_MAP: Record<string, string> = {
 };
 
 /**
- * Find a handler class in a dynamically imported module.
- * Checks default export first, then searches for the first class with `assign` on prototype.
+ * Criteria for locating an assignFrom handler class: must expose an `assign` method
+ * on its prototype.
  */
-function findHandlerInModule(module: any): AssignFromHandlerConstructor | undefined {
-    // Check default export first
-    if (module.default && typeof module.default === 'function'
-        && module.default.prototype && 'assign' in module.default.prototype) {
-        return module.default;
-    }
-    // Search other exports
-    for (const key of Object.keys(module)) {
-        const exported = module[key];
-        if (typeof exported === 'function' && exported.prototype && 'assign' in exported.prototype) {
-            return exported as AssignFromHandlerConstructor;
-        }
-    }
-    return undefined;
+function handlerCriteria(proto: any): boolean {
+    return 'assign' in proto.prototype;
 }
 
 /**
@@ -59,10 +48,9 @@ async function loadBuiltIn(name: string): Promise<AssignFromHandlerConstructor |
     if (cached) return cached;
     const path = BUILT_IN_MAP[name];
     if (!path) return undefined;
-    const module = await import(path);
-    const cls = findHandlerInModule(module);
-    if (cls) handlerCache.set(name, cls);
-    return cls;
+    const cls = await findClassPrototypeInPath(path, handlerCriteria);
+    handlerCache.set(name, cls);
+    return cls as AssignFromHandlerConstructor;
 }
 
 /**
@@ -70,8 +58,7 @@ async function loadBuiltIn(name: string): Promise<AssignFromHandlerConstructor |
  */
 async function resolveFromHandlers(
     name: string,
-    handlers: Record<string, AssignFromHandlerConstructor | string> | undefined,
-    permissions?: AssignPermissions
+    handlers: Record<string, AssignFromHandlerConstructor | string> | undefined
 ): Promise<AssignFromHandlerConstructor | undefined> {
     if (!handlers || !(name in handlers)) return undefined;
 
@@ -89,22 +76,9 @@ async function resolveFromHandlers(
             return loadBuiltIn(entry);
         }
 
-        // Import path string — validate and dynamically import
-        if (!permissions?.crossDomainImports && !isAllowedImportPath(entry)) {
-            throw new Error(
-                `assignFrom: handler "${name}" has an invalid import path "${entry}". ` +
-                `Only relative, absolute, or bare specifier paths are allowed (no cross-domain URLs). ` +
-                `Pass { crossDomainImports: true } in permissions to override.`
-            );
-        }
-        const module = await import(entry);
-        const HandlerClass = findHandlerInModule(module);
-        if (!HandlerClass) {
-            throw new Error(
-                `assignFrom: handler "${name}" — module "${entry}" does not export a valid handler class.`
-            );
-        }
-        return HandlerClass;
+        // Import path string — validate and extract handler class via shared utility
+        const HandlerClass = await findClassPrototypeInPath(entry, handlerCriteria);
+        return HandlerClass as AssignFromHandlerConstructor;
     }
 
     return undefined;
@@ -203,7 +177,7 @@ export async function processHandlerCommands(
         for (const config of configs) {
             //return; //1.3ms
             // 1. Check options.handlers (local, per-call)
-            let HandlerClass = await resolveFromHandlers(config.do, options.handlers, permissions);
+            let HandlerClass = await resolveFromHandlers(config.do, options.handlers);
             //return; // 1.4
             // 2. Fallback to built-in auto-load
             if (!HandlerClass && config.do.startsWith('builtIns.')) {

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);
+}