assign-gingerly 0.0.75 → 0.0.77

package/{resolveIdRef.js → resolve/resolveIdRef.js}

@@ -78,7 +78,7 @@ export function resolveIdVariable(varName, target, pin) {
                 // Fire-and-forget: log correction suggestion
                 const capturedConfig = config;
                 const capturedVarName = varName;
-                import('./DX/pinCorrector.js').then(module => {
+                import('../DX/pinCorrector.js').then(module => {
                     module.logConfigCorrection(target, capturedVarName, capturedConfig);
                 }).catch(() => { });
             }

package/{resolveIdRef.ts → resolve/resolveIdRef.ts}

@@ -91,7 +91,7 @@ export function resolveIdVariable(
                 // Fire-and-forget: log correction suggestion
                 const capturedConfig = config;
                 const capturedVarName = varName;
-                import('./DX/pinCorrector.js').then(module => {
+                import('../DX/pinCorrector.js').then(module => {
                     module.logConfigCorrection(target, capturedVarName, capturedConfig);
                 }).catch(() => {});
             }

package/{resolveValues.ts → resolve/resolveValues.ts}

@@ -8,7 +8,7 @@
  */
 
 import { getValue, getValues } from './getValues.js';
-import type { ResolveValuesOptions } from './types/assign-gingerly/types.js';
+import type { ResolveValuesOptions } from '../types/assign-gingerly/types.js';
 
 export type { ResolveValuesOptions };
 

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

@@ -424,6 +424,11 @@ export interface GetValuesOptions extends IAssignGingerlyOptions {
    */
   root?: any;
 
+  /**
+   * Optional permission processor for guarding method calls during RHS resolution.
+   */
+  permissionProcessor?: PermissionProcessor;
+
   /**
    * Synchronous protocol handlers for resolving protocol-prefixed values.
    * Each handler receives the key portion and MUST return synchronously.
@@ -449,6 +454,11 @@ export interface ResolveValuesOptions extends IAssignGingerlyOptions {
    */
   root?: any;
 
+  /**
+   * Optional permission processor for guarding method calls during RHS resolution.
+   */
+  permissionProcessor?: PermissionProcessor;
+
   /**
    * Protocol handlers for resolving protocol-prefixed values (e.g., 'globalThis://key').
    * Each handler receives the key portion and returns the resolved value (sync or async).
@@ -474,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;
 }
 
 /**
@@ -642,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.
@@ -695,7 +707,7 @@ export interface HandlerConfig {
  * Handlers are invoked when a LHS key ends with ' =>'.
  */
 export interface AssignFromHandler {
-    assign(lhsTarget: any, resolvedParams: Record<string, any>, options: any, permissions?: AssignPermissions): Promise<void> | void;
+    assign(lhsTarget: any, resolvedParams: Record<string, any>, options: any, permissionProcessor?: PermissionProcessor): Promise<void> | void;
 }
 
 /**
@@ -873,7 +885,7 @@ export interface LazyLoadInstantiatedContext {
 export declare class LazyLoadHandler implements AssignFromHandler {
     config: any;
     constructor(config: any);
-    assign(lhsTarget: any, resolvedParams: Record<string, any>, options?: any, permissions?: AssignPermissions): Promise<void>;
+    assign(lhsTarget: any, resolvedParams: Record<string, any>, options?: any, permissionProcessor?: PermissionProcessor): Promise<void>;
     protected onCloneInserted(nodes: Node[], lhsTarget: Element, resolvedParams: Record<string, any>): Promise<void>;
 }
 
@@ -931,11 +943,11 @@ export interface AddEventListenerConfig extends AssignDispatchVector  {
  * Phase II+: object form for a restricted property setting.
  */
 export interface RestrictedPropSetting {
-    prop: string;
-    useMethod?: string;          // Phase II: redirect to a safe method
-    attr?: string;               // Phase III: also watch setAttribute for this attr
-    allowFromSameHost?: boolean; // Phase III
-    allowCrossDomain?: boolean;  // Phase III
+    props: string | string[];
+    useMethod?: string;            // Phase II: redirect to a safe method
+    attr?: boolean | string | string[]; // Phase III: also watch setAttribute for these attrs
+    allowFromSameDomain?: boolean; // Phase III: allow same-origin URLs
+    allowCrossDomain?: boolean;    // Phase III: allow any URL
 }
 
 /**
@@ -958,7 +970,8 @@ export interface AssignPermissions {
      * Restricted property settings.
      * Phase I: string entries are property names that cannot be assigned.
      * Phase II: an object with useMethod redirects ordinary assignment to that
-     * method; command operations remain blocked. Phase III+ adds attr support.
+     * method; command operations remain blocked. Phase III+ adds props, attr,
+     * allowFromSameDomain, and allowCrossDomain support.
      *
      * NOTE: This is a property-assignment guard only. Method calls (setAttribute, etc.)
      * are not blocked — see Phase III+. Event listeners can still be registered, but
@@ -972,3 +985,21 @@ export interface AssignPermissions {
     /** Restricted method settings (Phase IV+) */
     restrictedMethodSettings?: Array<string | RestrictedMethodConfig>;
 }
+
+//#region Permissions
+export interface RestrictedPropSettingsMap {
+    props: Map<string, RestrictedPropSetting | undefined>;
+    attrs: Map<string, RestrictedPropSetting | undefined>;
+}
+
+export declare class PermissionProcessor {
+    constructor(permissions: AssignPermissions | undefined);
+    get crossDomainImports(): boolean;
+    get hasProps(): boolean;
+    get hasAttrs(): boolean;
+    checkRestrictedProp(key: string): boolean;
+    checkRestrictedMethod(methodName: string): boolean;
+    redirectRestrictedProp(target: any, key: string, value: any): boolean;
+    checkRestrictedAttributeCall(methodName: string, args: any[]): { blocked: boolean; attrName?: string };
+}
+//#endregion

package/assignPermissions/restrictedProps.js

@@ -1,43 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/resolveAndAssignFeatures.js

@@ -1,36 +0,0 @@
-/**
- * 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 { 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, featuresConfig, registry) {
-    const reg = registry || customElements;
-    await assignFeatures(ElementClass, featuresConfig, reg.featuresRegistry);
-}

package/resolveAndAssignFeatures.ts

@@ -1,43 +0,0 @@
-/**
- * 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);
-}