assign-gingerly 0.0.72 → 0.0.74

package/assignFrom.ts

@@ -13,7 +13,7 @@ import { getValues, getValue } from './getValues.js';
 import assignGingerly from './assignGingerly.js';
 import { resolveIdVariable, parseIdRef } from './resolveIdRef.js';
 import { processInferredAssignments } from './inferredAssignments.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
 import type { AssignFromOptions, AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 
 // Re-export types for consumers

package/assignFromAsync.ts

@@ -22,7 +22,7 @@
 import { resolveValues } from './resolveValues.js';
 import {IAssignGingerlyOptions} from './types/assign-gingerly/types.js';
 import assignGingerly from './assignGingerly.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
 import type { AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 import {
   expandSubstitutions, categorizeKeys, handleSpreads, isHandlerCommand

package/assignGingerly.js

@@ -1,4 +1,4 @@
-import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './isAllowedImportPath.js';
+import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 import { normalizeAliasOptions } from './getValues.js';
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions

package/assignGingerly.ts

@@ -2,8 +2,9 @@
 
 import { EnhancementConfig } from "./types/assign-gingerly/types";
 import type { AssignFromOptions, FeatureConfigsMap, IAssignGingerlyOptions } from "./types/assign-gingerly/types";
-import type { AssignPermissions, RestrictedPropSettingsMap } from "./isAllowedImportPath.js";
-import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
+import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
+import type { RestrictedPropSettingsMap } from './assignPermissions/restrictedProps.js';
 import { normalizeAliasOptions } from './getValues.js';
 
 /**

package/assignPermissions/isAllowedImportPath.js

@@ -0,0 +1,41 @@
+/**
+ * Check whether an import specifier resolves to the current origin or is
+ * covered by an import-map entry.
+ */
+export function isAllowedImportPath(value) {
+    if (typeof document === 'undefined' || typeof location === 'undefined')
+        return false;
+    if (!value || !(value.startsWith('./') || value.startsWith('../') || value.startsWith('/'))) {
+        return isImportMapSpecifier(value);
+    }
+    try {
+        return new URL(value, document.baseURI).origin === location.origin;
+    }
+    catch {
+        return false;
+    }
+}
+function isImportMapSpecifier(value) {
+    const importMaps = document.querySelectorAll('script[type="importmap"]');
+    for (const importMap of importMaps) {
+        try {
+            const parsed = JSON.parse(importMap.textContent ?? '');
+            if (!isImportMap(parsed))
+                continue;
+            for (const key of Object.keys(parsed.imports)) {
+                if (key.endsWith('/') ? value.startsWith(key) : value === key)
+                    return true;
+            }
+        }
+        catch {
+            // Ignore malformed import maps and continue searching.
+        }
+    }
+    return false;
+}
+function isImportMap(value) {
+    if (!value || typeof value !== 'object' || !('imports' in value))
+        return false;
+    const { imports } = value;
+    return !!imports && typeof imports === 'object' && !Array.isArray(imports);
+}

package/assignPermissions/isAllowedImportPath.ts

@@ -0,0 +1,38 @@
+/**
+ * Check whether an import specifier resolves to the current origin or is
+ * covered by an import-map entry.
+ */
+export function isAllowedImportPath(value: string): boolean {
+    if (typeof document === 'undefined' || typeof location === 'undefined') return false;
+    if (!value || !(value.startsWith('./') || value.startsWith('../') || value.startsWith('/'))) {
+        return isImportMapSpecifier(value);
+    }
+
+    try {
+        return new URL(value, document.baseURI).origin === location.origin;
+    } catch {
+        return false;
+    }
+}
+
+function isImportMapSpecifier(value: string): boolean {
+    const importMaps = document.querySelectorAll('script[type="importmap"]');
+    for (const importMap of importMaps) {
+        try {
+            const parsed = JSON.parse(importMap.textContent ?? '');
+            if (!isImportMap(parsed)) continue;
+            for (const key of Object.keys(parsed.imports)) {
+                if (key.endsWith('/') ? value.startsWith(key) : value === key) return true;
+            }
+        } catch {
+            // Ignore malformed import maps and continue searching.
+        }
+    }
+    return false;
+}
+
+function isImportMap(value: unknown): value is { imports: Record<string, unknown> } {
+    if (!value || typeof value !== 'object' || !('imports' in value)) return false;
+    const { imports } = value;
+    return !!imports && typeof imports === 'object' && !Array.isArray(imports);
+}

package/assignPermissions/restrictedProps.js

@@ -0,0 +1,43 @@
+const warnedOnce = new Set();
+function warnRestricted(key) {
+    if (!warnedOnce.has(key)) {
+        warnedOnce.add(key);
+        console.warn(`assignGingerly: property '${key}' is in restrictedPropSettings — assignment skipped.`);
+    }
+}
+export function buildRestrictedPropSet(permissions) {
+    const settings = permissions?.restrictedPropSettings;
+    if (!settings || settings.length === 0)
+        return undefined;
+    const restrictedPropSet = new Map();
+    for (const setting of settings) {
+        const prop = typeof setting === 'string' ? setting : setting.prop;
+        if (restrictedPropSet.has(prop)) {
+            throw new Error(`assignGingerly: duplicate restrictedPropSettings entry for '${prop}'.`);
+        }
+        restrictedPropSet.set(prop, typeof setting === 'string' ? undefined : setting);
+    }
+    return restrictedPropSet;
+}
+export function checkRestrictedProp(restrictedPropSet, key) {
+    if (!restrictedPropSet || !restrictedPropSet.has(key))
+        return false;
+    warnRestricted(key);
+    return true;
+}
+export function redirectRestrictedProp(restrictedPropSet, target, key, value) {
+    if (!restrictedPropSet || !restrictedPropSet.has(key))
+        return false;
+    const setting = restrictedPropSet.get(key);
+    if (!setting?.useMethod) {
+        warnRestricted(key);
+        return true;
+    }
+    const method = target?.[setting.useMethod];
+    if (typeof method !== 'function') {
+        warnRestricted(key);
+        return true;
+    }
+    method.call(target, value);
+    return true;
+}

package/assignPermissions/restrictedProps.ts

@@ -0,0 +1,53 @@
+import type { AssignPermissions, RestrictedPropSetting } from '../types/assign-gingerly/types.js';
+
+export type RestrictedPropSettingsMap = Map<string, RestrictedPropSetting | undefined>;
+
+const warnedOnce = new Set<string>();
+
+function warnRestricted(key: string): void {
+    if (!warnedOnce.has(key)) {
+        warnedOnce.add(key);
+        console.warn(`assignGingerly: property '${key}' is in restrictedPropSettings — assignment skipped.`);
+    }
+}
+
+export function buildRestrictedPropSet(permissions: AssignPermissions | undefined): RestrictedPropSettingsMap | undefined {
+    const settings = permissions?.restrictedPropSettings;
+    if (!settings || settings.length === 0) return undefined;
+    const restrictedPropSet: RestrictedPropSettingsMap = new Map();
+    for (const setting of settings) {
+        const prop = typeof setting === 'string' ? setting : setting.prop;
+        if (restrictedPropSet.has(prop)) {
+            throw new Error(`assignGingerly: duplicate restrictedPropSettings entry for '${prop}'.`);
+        }
+        restrictedPropSet.set(prop, typeof setting === 'string' ? undefined : setting);
+    }
+    return restrictedPropSet;
+}
+
+export function checkRestrictedProp(restrictedPropSet: RestrictedPropSettingsMap | undefined, key: string): boolean {
+    if (!restrictedPropSet || !restrictedPropSet.has(key)) return false;
+    warnRestricted(key);
+    return true;
+}
+
+export function redirectRestrictedProp(
+    restrictedPropSet: RestrictedPropSettingsMap | undefined,
+    target: any,
+    key: string,
+    value: any
+): boolean {
+    if (!restrictedPropSet || !restrictedPropSet.has(key)) return false;
+    const setting = restrictedPropSet.get(key);
+    if (!setting?.useMethod) {
+        warnRestricted(key);
+        return true;
+    }
+    const method = target?.[setting.useMethod];
+    if (typeof method !== 'function') {
+        warnRestricted(key);
+        return true;
+    }
+    method.call(target, value);
+    return true;
+}

package/assignTentatively.js

@@ -1,4 +1,4 @@
-import { buildRestrictedPropSet, checkRestrictedProp } from './isAllowedImportPath.js';
+import { buildRestrictedPropSet, checkRestrictedProp } from './assignPermissions/restrictedProps.js';
 /**
  * Helper function to check if a string key represents an += command
  */

package/assignTentatively.ts

@@ -2,8 +2,8 @@
  * assignTentatively — reversible assignment with change tracking.
  */
 import type { IAssignTentativelyOptions } from './types/assign-gingerly/types.js';
-import type { AssignPermissions } from './isAllowedImportPath.js';
-import { buildRestrictedPropSet, checkRestrictedProp } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
+import { buildRestrictedPropSet, checkRestrictedProp } from './assignPermissions/restrictedProps.js';
 export type { IAssignTentativelyOptions };
 
 /**

package/defineWithFeatures.js

@@ -1,9 +1,9 @@
 /**
  * defineWithFeatures - Declaratively define a custom element with features from JSON config.
  *
- * Resolves async fallback spawns from the base class's `static supportedFeatures`,
- * creates a subclass, registers features with resolved spawns + JSON config,
- * and defines the custom element.
+ * A thin wrapper around assignFeatures: waits for the base class, creates a subclass,
+ * optionally calls onSubclassCreated, awaits assignFeatures(NewClass, config.assignFeatures),
+ * then defines the custom element in the registry.
  *
  * Designed to support cede scripts and other declarative custom element definition patterns.
  *
@@ -20,30 +20,13 @@
  * });
  */
 import { assignFeatures } from './assignFeatures.js';
-/**
- * Determines if a function is an async spawner (same heuristic as assignFeatures).
- */
-function isAsyncSpawn(fn) {
-    if (typeof fn !== 'function')
-        return false;
-    if (fn.constructor.name === 'AsyncFunction')
-        return true;
-    if (fn.prototype === undefined)
-        return true;
-    return false;
-}
-/**
- * Cache for resolved fallback spawns.
- * Key: BaseClass, Value: Map<featureKey, resolvedConstructor>
- */
-const resolvedSpawnCache = new WeakMap();
 /**
  * Declaratively define a custom element with features.
  *
  * 1. Waits for the base class to be defined (if not already).
- * 2. Resolves all async fallback spawns from `static supportedFeatures`.
- * 3. Creates a subclass extending the base class.
- * 4. Calls `assignFeatures` with resolved spawns + the JSON config.
+ * 2. Creates a subclass extending the base class.
+ * 3. Calls the optional onSubclassCreated callback.
+ * 4. Calls assignFeatures with the JSON config and the registry's featuresRegistry.
  * 5. Defines the new custom element in the registry.
  *
  * @param tagName - The custom element tag name to define (e.g., 'time-ticker')
@@ -63,62 +46,19 @@ export async function defineWithFeatures(tagName, baseTagName, config, registry,
     if (!BaseClass) {
         throw new Error(`defineWithFeatures: base class "${baseTagName}" could not be resolved`);
     }
-    const supportedFeatures = BaseClass.supportedFeatures;
-    if (!supportedFeatures) {
-        throw new Error(`defineWithFeatures: "${baseTagName}" does not define static supportedFeatures`);
-    }
-    // 2. Resolve all async fallback spawns (with caching)
-    let classCache = resolvedSpawnCache.get(BaseClass);
-    if (!classCache) {
-        classCache = new Map();
-        resolvedSpawnCache.set(BaseClass, classCache);
-    }
-    const { assignFeatures: af } = config;
-    let resolvedSpawns;
-    if (af) {
-        const featureKeys = Object.keys(af);
-        resolvedSpawns = new Map();
-        await Promise.all(featureKeys.map(async (key) => {
-            const optIn = supportedFeatures[key];
-            if (!optIn) {
-                throw new Error(`defineWithFeatures: feature "${key}" not found in ${baseTagName}.supportedFeatures`);
-            }
-            // Check cache first
-            if (classCache.has(key)) {
-                resolvedSpawns.set(key, classCache.get(key));
-                return;
-            }
-            let spawn = optIn.fallbackSpawn;
-            if (spawn && isAsyncSpawn(spawn)) {
-                // Resolve the async spawner
-                spawn = await spawn();
-            }
-            // Cache the resolved spawn
-            if (spawn) {
-                classCache.set(key, spawn);
-            }
-            resolvedSpawns.set(key, spawn);
-        }));
-    }
-    // 3. Create subclass
+    // 2. Create subclass
     const NewClass = class extends BaseClass {
     };
-    // 3b. Call onSubclassCreated callback (before define, before features if needed)
+    // 3. Optional subclass callback
     if (options?.onSubclassCreated) {
         options.onSubclassCreated(NewClass);
     }
+    // 4. Assign features (assignFeatures resolves all spawns and installs getters)
+    const { assignFeatures: af } = config;
     if (af) {
-        // 4. Build FeatureConfigsMap: resolved spawns + JSON config
-        const featuresMap = {};
-        for (const [key, jsonConfig] of Object.entries(af)) {
-            featuresMap[key] = {
-                spawn: resolvedSpawns.get(key),
-                ...jsonConfig
-            };
-        }
-        // 5. assignFeatures (sequential onAssigned) + define
-        await assignFeatures(NewClass, featuresMap, reg.featuresRegistry);
+        await assignFeatures(NewClass, af, reg.featuresRegistry);
     }
+    // 5. Define the custom element
     reg.define(tagName, NewClass);
     return NewClass;
 }

package/defineWithFeatures.ts

@@ -1,167 +1,92 @@
-/**
- * defineWithFeatures - Declaratively define a custom element with features from JSON config.
- * 
- * Resolves async fallback spawns from the base class's `static supportedFeatures`,
- * creates a subclass, registers features with resolved spawns + JSON config,
- * and defines the custom element.
- * 
- * Designed to support cede scripts and other declarative custom element definition patterns.
- * 
- * @example
- * await defineWithFeatures('time-ticker', 'el-maker', {
- *     assignFeatures: {
- *         timeTicker: {},
- *         roundabout: {
- *             customData: {...},
- *             withAttrs: {...},
- *             callbackForwarding: ['connectedCallback']
- *         }
- *     }
- * });
- */
-
-import { assignFeatures, FeatureConfigsMap, SupportedFeaturesMap } from './assignFeatures.js';
-
-/**
- * Configuration passed to defineWithFeatures (JSON-serializable).
- */
-export interface DefineWithFeaturesConfig {
-    assignFeatures: Record<string, {
-        customData?: any;
-        withAttrs?: any;
-        callbackForwarding?: string[];
-    }>;
-}
-
-/**
- * Options for defineWithFeatures.
- */
-export interface DefineWithFeaturesOptions {
-    /** Called after the subclass is created but before registry.define(). */
-    onSubclassCreated?: (NewCtr: Function) => void;
-}
-
-/**
- * Determines if a function is an async spawner (same heuristic as assignFeatures).
- */
-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;
-}
-
-/**
- * Cache for resolved fallback spawns.
- * Key: BaseClass, Value: Map<featureKey, resolvedConstructor>
- */
-const resolvedSpawnCache = new WeakMap<Function, Map<string, any>>();
-
-/**
- * Declaratively define a custom element with features.
- * 
- * 1. Waits for the base class to be defined (if not already).
- * 2. Resolves all async fallback spawns from `static supportedFeatures`.
- * 3. Creates a subclass extending the base class.
- * 4. Calls `assignFeatures` with resolved spawns + the JSON config.
- * 5. Defines the new custom element in the registry.
- * 
- * @param tagName - The custom element tag name to define (e.g., 'time-ticker')
- * @param baseTagName - The tag name of the base class to extend (e.g., 'el-maker')
- * @param config - JSON-serializable configuration specifying which features to activate
- * @param registry - Optional custom element registry (defaults to global `customElements`)
- * @returns The newly created and defined custom element class
- */
-export async function defineWithFeatures(
-    tagName: string,
-    baseTagName: string,
-    config: DefineWithFeaturesConfig,
-    registry?: CustomElementRegistry,
-    options?: DefineWithFeaturesOptions
-): Promise<Function> {
-    const reg = registry || customElements;
-
-    // 1. Resolve base class — wait for it if not yet defined
-    let BaseClass = (reg as any).get(baseTagName);
-    if (!BaseClass) {
-        await (reg as any).whenDefined(baseTagName);
-        BaseClass = (reg as any).get(baseTagName);
-    }
-    if (!BaseClass) {
-        throw new Error(`defineWithFeatures: base class "${baseTagName}" could not be resolved`);
-    }
-
-    const supportedFeatures: SupportedFeaturesMap | undefined = BaseClass.supportedFeatures;
-    if (!supportedFeatures) {
-        throw new Error(
-            `defineWithFeatures: "${baseTagName}" does not define static supportedFeatures`
-        );
-    }
-
-    // 2. Resolve all async fallback spawns (with caching)
-    let classCache = resolvedSpawnCache.get(BaseClass);
-    if (!classCache) {
-        classCache = new Map();
-        resolvedSpawnCache.set(BaseClass, classCache);
-    }
-    const {assignFeatures: af} = config;
-    let resolvedSpawns: Map<string, any> | undefined;
-    if (af) {
-        const featureKeys = Object.keys(af);
-        resolvedSpawns = new Map<string, any>();
-
-        await Promise.all(featureKeys.map(async (key) => {
-            const optIn = supportedFeatures[key];
-            if (!optIn) {
-                throw new Error(
-                    `defineWithFeatures: feature "${key}" not found in ${baseTagName}.supportedFeatures`
-                );
-            }
-
-            // Check cache first
-            if (classCache!.has(key)) {
-                resolvedSpawns!.set(key, classCache!.get(key));
-                return;
-            }
-
-            let spawn = optIn.fallbackSpawn;
-            if (spawn && isAsyncSpawn(spawn)) {
-                // Resolve the async spawner
-                spawn = await (spawn as () => Promise<any>)();
-            }
-
-            // Cache the resolved spawn
-            if (spawn) {
-                classCache!.set(key, spawn);
-            }
-            resolvedSpawns!.set(key, spawn);
-        }));
-    }
-
-
-    // 3. Create subclass
-    const NewClass = class extends (BaseClass as any) { };
-
-    // 3b. Call onSubclassCreated callback (before define, before features if needed)
-    if (options?.onSubclassCreated) {
-        options.onSubclassCreated(NewClass);
-    }
-
-    if(af){
-        // 4. Build FeatureConfigsMap: resolved spawns + JSON config
-        const featuresMap: FeatureConfigsMap = {};
-        for (const [key, jsonConfig] of Object.entries(af)) {
-            featuresMap[key] = {
-                spawn: resolvedSpawns!.get(key),
-                ...jsonConfig
-            };
-        }
-
-        // 5. assignFeatures (sequential onAssigned) + define
-        await assignFeatures(NewClass, featuresMap, (reg as any).featuresRegistry);
-    }
-
-    (reg as any).define(tagName, NewClass);
-
-    return NewClass;
-}
+/**
+ * defineWithFeatures - Declaratively define a custom element with features from JSON config.
+ * 
+ * A thin wrapper around assignFeatures: waits for the base class, creates a subclass,
+ * optionally calls onSubclassCreated, awaits assignFeatures(NewClass, config.assignFeatures),
+ * then defines the custom element in the registry.
+ * 
+ * Designed to support cede scripts and other declarative custom element definition patterns.
+ * 
+ * @example
+ * await defineWithFeatures('time-ticker', 'el-maker', {
+ *     assignFeatures: {
+ *         timeTicker: {},
+ *         roundabout: {
+ *             customData: {...},
+ *             withAttrs: {...},
+ *             callbackForwarding: ['connectedCallback']
+ *         }
+ *     }
+ * });
+ */
+
+import { assignFeatures, FeatureConfigsMap } from './assignFeatures.js';
+
+/**
+ * Configuration passed to defineWithFeatures (JSON-serializable).
+ */
+export interface DefineWithFeaturesConfig {
+    assignFeatures: FeatureConfigsMap;
+}
+
+/**
+ * Options for defineWithFeatures.
+ */
+export interface DefineWithFeaturesOptions {
+    /** Called after the subclass is created but before registry.define(). */
+    onSubclassCreated?: (NewCtr: Function) => void;
+}
+
+/**
+ * Declaratively define a custom element with features.
+ * 
+ * 1. Waits for the base class to be defined (if not already).
+ * 2. Creates a subclass extending the base class.
+ * 3. Calls the optional onSubclassCreated callback.
+ * 4. Calls assignFeatures with the JSON config and the registry's featuresRegistry.
+ * 5. Defines the new custom element in the registry.
+ * 
+ * @param tagName - The custom element tag name to define (e.g., 'time-ticker')
+ * @param baseTagName - The tag name of the base class to extend (e.g., 'el-maker')
+ * @param config - JSON-serializable configuration specifying which features to activate
+ * @param registry - Optional custom element registry (defaults to global `customElements`)
+ * @returns The newly created and defined custom element class
+ */
+export async function defineWithFeatures(
+    tagName: string,
+    baseTagName: string,
+    config: DefineWithFeaturesConfig,
+    registry?: CustomElementRegistry,
+    options?: DefineWithFeaturesOptions
+): Promise<Function> {
+    const reg = registry || customElements;
+
+    // 1. Resolve base class — wait for it if not yet defined
+    let BaseClass = (reg as any).get(baseTagName);
+    if (!BaseClass) {
+        await (reg as any).whenDefined(baseTagName);
+        BaseClass = (reg as any).get(baseTagName);
+    }
+    if (!BaseClass) {
+        throw new Error(`defineWithFeatures: base class "${baseTagName}" could not be resolved`);
+    }
+
+    // 2. Create subclass
+    const NewClass = class extends (BaseClass as any) { };
+
+    // 3. Optional subclass callback
+    if (options?.onSubclassCreated) {
+        options.onSubclassCreated(NewClass);
+    }
+
+    // 4. Assign features (assignFeatures resolves all spawns and installs getters)
+    const { assignFeatures: af } = config;
+    if (af) {
+        await assignFeatures(NewClass, af, (reg as any).featuresRegistry);
+    }
+
+    // 5. Define the custom element
+    (reg as any).define(tagName, NewClass);
+
+    return NewClass;
+}

package/eachTime.js

@@ -3,7 +3,7 @@
  * This module is dynamically loaded only when @eachTime is encountered
  * Provides event-driven iteration over elements as they mount
  */
-import { redirectRestrictedProp } from './isAllowedImportPath.js';
+import { redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 /**
  * Check if a value is an EventTarget
  */

package/eachTime.ts

@@ -5,8 +5,9 @@
  */
 
 import type { IAssignGingerlyOptions } from './types/assign-gingerly/types.js';
-import type { AssignPermissions, RestrictedPropSettingsMap } from './isAllowedImportPath.js';
-import { redirectRestrictedProp } from './isAllowedImportPath.js';
+import type { AssignPermissions } from './types/assign-gingerly/types.js';
+import { redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
+import type { RestrictedPropSettingsMap } from './assignPermissions/restrictedProps.js';
 
 /**
  * Check if a value is an EventTarget