mount-observer 0.1.37 → 0.1.38

package/handlers/EMCScript.js

@@ -130,12 +130,19 @@ export class EMCScriptHandler extends EvtRt {
      */
     async handleMount(mountedElement, emcConfig, synthesizerElement) {
         const enhKey = emcConfig.enhConfig.enhKey;
-        // Step 1: Check if element already has this enhancement
+        // Step 1: Check if element already has this enhancement or is currently being enhanced
         const enh = mountedElement.enh;
         if (enh && enh[enhKey]) {
             // Already enhanced, do nothing
             return;
         }
+        // Check for in-flight enhancement to prevent duplicate spawns
+        // when multiple observers match the same element concurrently
+        const inflightKey = `__enhInFlight_${String(enhKey)}`;
+        if (mountedElement[inflightKey]) {
+            return;
+        }
+        mountedElement[inflightKey] = true;
         // Step 2: Get enhancement registry from the element's custom element registry
         const customElementRegistry = mountedElement.customElementRegistry || customElements;
         const enhancementRegistry = customElementRegistry.enhancementRegistry;

package/handlers/EMCScript.ts

@@ -152,13 +152,21 @@ export class EMCScriptHandler extends EvtRt {
     private async handleMount(mountedElement: Element, emcConfig: EMC, synthesizerElement?: Element): Promise<void> {
         const enhKey = emcConfig.enhConfig.enhKey;
         
-        // Step 1: Check if element already has this enhancement
+        // Step 1: Check if element already has this enhancement or is currently being enhanced
         const enh = (mountedElement as any).enh;
         if (enh && enh[enhKey]) {
             // Already enhanced, do nothing
             return;
         }
         
+        // Check for in-flight enhancement to prevent duplicate spawns
+        // when multiple observers match the same element concurrently
+        const inflightKey = `__enhInFlight_${String(enhKey)}`;
+        if ((mountedElement as any)[inflightKey]) {
+            return;
+        }
+        (mountedElement as any)[inflightKey] = true;
+        
         // Step 2: Get enhancement registry from the element's custom element registry
         const customElementRegistry = (mountedElement as any).customElementRegistry || customElements;
         const enhancementRegistry = (customElementRegistry as any).enhancementRegistry;

package/handlers/ScriptExport.js

@@ -33,7 +33,6 @@ export class ScriptExportHandler extends EvtRt {
         const scriptElement = mountedElement;
         // Optimization 3: Skip if already processed (export property exists)
         if (scriptElement.export !== undefined) {
-            console.log('ScriptExport: Skipping already processed script element');
             return;
         }
         // Skip if this is a module script (browser handles these)

package/handlers/ScriptExport.ts

@@ -38,7 +38,6 @@ export class ScriptExportHandler extends EvtRt {
         
         // Optimization 3: Skip if already processed (export property exists)
         if ((scriptElement as any).export !== undefined) {
-            console.log('ScriptExport: Skipping already processed script element');
             return;
         }
         

package/index.js

@@ -12,6 +12,7 @@ export { MountObserverScriptHandler } from './handlers/MountObserverScript.js';
 export { EMCScriptHandler } from './handlers/EMCScript.js';
 export { HoistTemplateHandler } from './handlers/HoistTemplate.js';
 export { HTMLIncludeHandler } from './handlers/HTMLInclude.js';
+export { CedeScriptHandler } from './handlers/CedeScript.js';
 export { upShadowSearch } from './upShadowSearch.js';
 export { mountEventName, dismountEventName, disconnectEventName, loadEventName, mediamatchEventName, mediaunmatchEventName, addedScriptElementEventName } from './Events.js';
 // Register built-in handlers
@@ -24,3 +25,4 @@ import './handlers/MountObserverScript.js';
 import './handlers/EMCScript.js';
 import './handlers/HoistTemplate.js';
 import './handlers/HTMLInclude.js';
+import './handlers/CedeScript.js';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mount-observer",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "Observe and act on css matches.",
   "main": "MountObserver.js",
   "module": "MountObserver.js",
   "dependencies": {
-    "assign-gingerly": "0.0.50",
+    "assign-gingerly": "0.0.51",
     "id-generation": "0.0.4"
   },
   "devDependencies": {

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

@@ -179,13 +179,18 @@ export interface AttrConfig<T = unknown, TParserConfig = unknown> {
   //  * Defaults to true (initial read only)
   //  */
   // initialOnly?: boolean;
+
+  /**
+   * Should make sure it is added to static observedAttribrutes
+   */
+  sourceOfTruth?: boolean;
 }
 
 export type AttrPatterns<T = any> = {
   /**
    * Base prefix for attribute names
    */
-  base: string;
+  base?: string;
 
   /**
    * Configuration for the base pattern
@@ -321,3 +326,151 @@ export interface ElementEnhancement{
   dispose(registryItem: EnhancementConfig | string | symbol): void;
   whenResolved(registryItem: EnhancementConfig | string | symbol, mountCtx?: any): Promise<any>;
 }
+
+// =============================================================================
+// Custom Element Features types
+// =============================================================================
+
+/**
+ * Context passed to feature spawn constructors
+ */
+export interface FeatureSpawnContext {
+    /** The feature key (e.g., 'photoTaker') */
+    key: string;
+    /** The SupportedFeatureConfig from static supportedFeatures */
+    optIn: SupportedFeatureConfig;
+    /** The FeatureConfig from assignFeatures */
+    injection: FeatureConfig;
+    /** The features registry reference */
+    featuresRegistry: FeaturesRegistry;
+    /** Shared context from the host element (via getSharedContext callback) */
+    shared?: any;
+}
+
+/**
+ * Configuration for a supported feature slot declared via static supportedFeatures
+ */
+export interface SupportedFeatureConfig {
+    /**
+     * Optional fallback class (or async spawner) to use if no implementation is injected.
+     */
+    fallbackSpawn?:
+        | { new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }
+        | (() => Promise<{ new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }>);
+
+    /**
+     * Optional runtime shape validation for the spawned instance.
+     * Return true if the instance is valid, false to throw.
+     */
+    validateShape?: (spawnedInstance: any) => boolean;
+
+    /**
+     * Optional callback to provide shared context (e.g., ElementInternals, private state)
+     * to the feature at construction time.
+     */
+    getSharedContext?: (instance: any) => any;
+
+    /**
+     * Lifecycle callbacks that this feature requires.
+     * Serves as the default — the consumer can add more via FeatureConfig.callbackForwarding.
+     */
+    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.
+ */
+export interface FeatureConfig {
+    /**
+     * The class to instantiate, or an async function returning one.
+     */
+    spawn?:
+        | { new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }
+        | (() => Promise<{ new(hostElement: any, ctx: FeatureSpawnContext, initVals?: any): any }>);
+
+    /** Attribute patterns for parsing element attributes into initVals. */
+    withAttrs?: AttrPatterns<any>;
+
+    /** Pass-through custom configuration data (accessible via ctx.injection.customData). */
+    customData?: any;
+
+    /** Lifecycle callbacks to forward to this feature. */
+    callbackForwarding?: string[];
+}
+
+export type SupportedFeaturesMap = Record<string, SupportedFeatureConfig>;
+export type FeatureConfigsMap = Record<string, FeatureConfig>;
+
+/**
+ * Registry for feature configs, keyed by constructor.
+ */
+export declare class FeaturesRegistry {
+    has(ctr: Function): boolean;
+    get(ctr: Function): Map<string, FeatureConfig> | undefined;
+    set(ctr: Function, key: string, config: FeatureConfig): void;
+    hasKey(ctr: Function, key: string): boolean;
+}
+
+/**
+ * A suggestion from one feature to another.
+ */
+export interface FeatureInfoSuggestion {
+    from: Function;
+    withAttrs?: any;
+    customData?: any;
+}
+
+/**
+ * Core assignFeatures function.
+ */
+export declare function assignFeatures(
+    ctr: Function,
+    features: FeatureConfigsMap,
+    featuresRegistry: FeaturesRegistry
+): Promise<void> | undefined;
+
+/**
+ * Captures own-properties that shadow feature getters.
+ */
+export declare function captureFeatureInitVals(instance: any): void;
+
+/**
+ * Suggest configuration to another feature during registration.
+ */
+export declare function suggestFeatureInfo(
+    fromFeatureCtr: Function,
+    toFeatureSymbol: symbol,
+    featureInfo: { withAttrs?: any; customData?: any },
+    targetClass: Function
+): void;
+
+/**
+ * Retrieve suggestions made to a feature by other features.
+ */
+export declare function getFeatureInfoSuggestions(
+    toFeatureSymbol: symbol,
+    targetClass: Function
+): FeatureInfoSuggestion[];
+
+/**
+ * Base class for nested feature containers.
+ */
+export declare class PropertyBag {
+    customElementRegistry: any;
+    constructor(hostElement: any, ctx?: FeatureSpawnContext, initVals?: any);
+}

package/types/be-reflective/types.d.ts

@@ -0,0 +1,80 @@
+import { SpawnContext } from "../assign-gingerly/types";
+
+/**
+ * Shared context passed via getSharedContext — contains everything
+ * the Reflector needs to self-activate on spawn.
+ */
+export interface ReflectorSharedContext {
+    /** The ElementInternals instance for custom state manipulation */
+    internals: ElementInternals;
+    /** The EventTarget the host dispatches property change events on */
+    hostPropagator: EventTarget;
+}
+
+/**
+ * Context passed to the Reflector feature constructor
+ */
+export interface FeatureSpawnContext extends SpawnContext {
+    key: string;
+    optIn: any;
+    injection: any;
+    featuresRegistry: any;
+    shared?: ReflectorSharedContext;
+}
+
+/**
+ * A single custom state export rule parsed from --custom-state-exports
+ */
+export interface CustomStateRule {
+    /** The custom state name to toggle (e.g. "disabled", "alertTypeIndicatesSuccess") */
+    stateName: string;
+    /** The property name to observe */
+    propName: string;
+    /** The condition type */
+    conditionType: 'boolean' | 'equals' | 'contains' | 'endsWith' | 'modulo' | 'lessThan' | 'greaterThan' | 'lessThanOrEqual' | 'greaterThanOrEqual';
+    /** The comparison value (for non-boolean conditions) */
+    compareValue?: string | number;
+    /** The modulo divisor (for modulo conditions) */
+    moduloDivisor?: number;
+}
+
+/**
+ * Properties that the Reflector feature exposes.
+ * With callbackForwarding, hostPropagator is provided via getSharedContext
+ * and the feature self-activates — but the setter remains for manual use cases.
+ */
+export interface ReflectorProps {
+    /**
+     * The EventTarget that the host element uses to propagate property change events.
+     * Provided via getSharedContext. Also settable post-spawn for reconnection.
+     */
+    hostPropagator: EventTarget | null;
+}
+
+/**
+ * Internal state
+ */
+export interface AllProps extends ReflectorProps {
+    /**
+     * WeakRef to the host custom element
+     */
+    hostRef: WeakRef<HTMLElement> | null;
+
+    /**
+     * The ElementInternals instance from the host (for custom state manipulation)
+     */
+    internals: ElementInternals | null;
+
+    /**
+     * Parsed custom state rules from --custom-state-exports CSS property
+     */
+    rules: CustomStateRule[];
+
+    /**
+     * AbortController for cleaning up event listeners
+     */
+    abortController: AbortController | null;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;

package/types/do-inc/types.d.ts

@@ -1,4 +1,4 @@
-import { ElementEnhancementGateway } from "../assign-gingerly/types";
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
 import { StatementsResult } from "../nested-regex-groups/types";
 
 export interface EndUserProps{
@@ -19,7 +19,7 @@ export type ProPAP  = Promise<PAP>
 export interface Actions{
     hydrate(self: AP & Actions): ProPAP;
     handleEvent(self: AP, event: Event, incParameters: IncParameters): void;
-    init(self: AP, enhancedElement: Element, initVals: PAP): Promise<void>
+    init(self: AP, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>;
 }
 
 export type asOptions = 

package/types/do-merge/types.d.ts

@@ -0,0 +1,28 @@
+import { ElementEnhancementGateway, SpawnContext, IAssignGingerlyOptions } from "../assign-gingerly/types";
+
+export interface MergeParameters {
+    assign: Record<string, any>;
+    on?: string;
+    options?: IAssignGingerlyOptions;
+    targetElementId?: string;
+}
+
+export interface EndUserProps {
+    mergeParamSets: MergeParameters | MergeParameters[];
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element & ElementEnhancementGateway;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    hydrate(self: AP): ProPAP;
+}

package/types/do-toggle/types.d.ts

@@ -1,4 +1,4 @@
-import { ElementEnhancementGateway } from "../assign-gingerly/types";
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
 import { StatementsResult } from "../nested-regex-groups/types";
 
 export interface EndUserProps{}
@@ -16,7 +16,7 @@ export type PAP = Partial<AP>;
 export type ProPAP  = Promise<PAP>
 
 export interface Actions{
-    init(self: AllProps, enhancedElement: Element, initVals: PAP): void;
+    init(self: AllProps, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>;
     hydrate(self: AP): ProPAP;
     handleEvent(self: AP, e: Event, parsedStatement: TogglingParameters): void;
 }
@@ -24,4 +24,8 @@ export interface Actions{
 export interface TogglingParameters {
     prop?: string | null;
     localEventType?: string;
+    targetSpecifier: {
+        prop?: string;
+        targetElementId?: string;
+    };
 }

package/types/face-up/types.d.ts

@@ -0,0 +1,102 @@
+import { SpawnContext } from "../assign-gingerly/types";
+
+/**
+ * Shared context passed via getSharedContext — contains the
+ * ElementInternals instance needed for form control APIs.
+ */
+export interface FaceUpSharedContext {
+    /** The ElementInternals instance for form control APIs */
+    internals: ElementInternals;
+}
+
+/**
+ * Context passed to the FaceUp feature constructor
+ */
+export interface FeatureSpawnContext extends SpawnContext {
+    key: string;
+    optIn: any;
+    injection: any;
+    featuresRegistry: any;
+    shared?: FaceUpSharedContext;
+}
+
+/**
+ * Validation flags matching the ValidityStateFlags interface.
+ * Used with setValidity() to indicate the type of validation error.
+ */
+export interface ValidationFlags {
+    valueMissing?: boolean;
+    typeMismatch?: boolean;
+    patternMismatch?: boolean;
+    tooLong?: boolean;
+    tooShort?: boolean;
+    rangeUnderflow?: boolean;
+    rangeOverflow?: boolean;
+    stepMismatch?: boolean;
+    badInput?: boolean;
+    customError?: boolean;
+}
+
+/**
+ * Properties that the FaceUp feature exposes.
+ * These allow the host custom element to participate in HTML forms
+ * via the ElementInternals API.
+ *
+ * Because the feature is installed as a getter-only property,
+ * assignGingerly merges directly into the instance. The consumer
+ * simply sets properties (e.g., el.faceUp.value = x) and the
+ * setters handle syncing to ElementInternals automatically.
+ */
+export interface FaceUpProps {
+    /**
+     * The current form value of the control.
+     * Setting this calls setFormValue() on the internals.
+     */
+    value: string | File | FormData | null;
+
+    /**
+     * Internal state for form restoration (optional).
+     * If provided, passed as the second argument to setFormValue().
+     */
+    state: string | File | FormData | null;
+
+    /**
+     * Whether the control is currently disabled.
+     */
+    disabled: boolean;
+
+    /**
+     * Whether the control requires a value for form submission.
+     */
+    required: boolean;
+
+    /**
+     * Custom validation message. Setting a non-empty string
+     * marks the control as invalid with customError.
+     */
+    validationMessage: string;
+}
+
+/**
+ * Internal state
+ */
+export interface AllProps extends FaceUpProps {
+    /**
+     * WeakRef to the host custom element
+     */
+    hostRef: WeakRef<HTMLElement> | null;
+
+    /**
+     * The ElementInternals instance from the host (for form control APIs)
+     */
+    internals: ElementInternals | null;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;
+
+
+
+export interface CustomData {
+    integrateWithRoundabout: boolean;
+}

package/types/roundabout/types.d.ts

@@ -42,18 +42,17 @@ export type Actions<TProps = any, TActions = TProps> =
     //& Partial<{[key in `do_${keyof TActions & string}_on`]: Key<TActions> | Array<Key<TActions>> }> 
 ;
 
-export type Compacts<TProps = any, TActions = TProps> = 
-    //| Partial<{[key in `${keyof TProps & string}_to_${keyof TProps & string}` & string]: Operation<TProps> }>
-    | Partial<{[key in `negate_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
+export type Compacts<TProps = any, TActions = TProps, TEvents extends string = string> = 
+    Partial<{[key in `negate_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
     | Partial<{[key in `pass_length_of_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
     | Partial<{[key in `echo_${keyof TProps & string}_to_${keyof TProps & string}`]: number}>
     | Partial<{[key in `echo_${keyof TProps & string}_to_${keyof TProps & string}_after`]: keyof TProps}>
     | Partial<{[key in `when_${keyof TProps & string}_changes_call_${keyof TActions & string}`]: number}>
     | Partial<{[key in `when_${keyof TProps & string}_changes_toggle_${keyof TProps & string}`]: number}>
     | Partial<{[key in `when_${keyof TProps & string}_changes_inc_${keyof TProps & string}_by`]: number}>
-    | Partial<{[key in `when_${keyof TProps & string}_changes_dispatch`]: string}> //TODO
-    | Partial<{[key in `on_${string}_of_${keyof TProps & string}_inc_${keyof TProps & string}_by`]: number}>
-    | Partial<{[key in `on_${string}_of_${keyof TProps & string}_set_${keyof TProps & string}_to`]: any}>
+    | Partial<{[key in `when_${keyof TProps & string}_changes_dispatch`]: string}>
+    | Partial<{[key in `on_${TEvents}_of_${keyof TProps & string}_inc_${keyof TProps & string}_by`]: number}>
+    | Partial<{[key in `on_${TEvents}_of_${keyof TProps & string}_set_${keyof TProps & string}_to`]: any}>
 ;
 
 export type Hitches<TProps = any, TActions = TProps> = 
@@ -95,14 +94,48 @@ export interface Merge<TProps = any> extends LogicOp<TProps> {
 
 export type Merges<TProps = any> = Array<Merge<TProps>>;
 
-export interface RAConfig<TProps = unknown, TActions = TProps, ETProps = TProps, TCustomData = unknown> {
+/**
+ * A yield derives a value from a collection using an index or key.
+ * Scenario I: Single selection by index — when the source array or index changes,
+ * the target property is set to source[index].
+ */
+export interface YieldConfig<TProps = any> {
+    /** The source array/collection property name */
+    from: keyof TProps & string;
+    /** The index property name (for array index lookup) */
+    atIndex?: keyof TProps & string;
+    /**
+     * Behavior when the index is out of bounds.
+     * - 'undefined' (default): set target to undefined
+     * - 'clamp': reset the index to 0 (selects first item)
+     */
+    outOfBounds?: 'undefined' | 'clamp';
+    // Future: atKey, atIndices, keyProp, etc.
+}
+
+export type Yields<TProps = any> = {
+    [K in keyof TProps & string]?: YieldConfig<TProps>;
+};
+
+export interface RAConfig<
+        TProps = unknown, TActions = TProps, ETProps = TProps, 
+        TCustomData = unknown, TEvents extends string = string > {
     actions?: Actions<TProps,TActions>,
-    compacts?: Compacts<TProps, TActions>,
+    compacts?: Compacts<TProps, TActions, TEvents>,
     //onsets?: Onsets<TProps, TActions>,
     handlers?: Handlers<ETProps, TActions>,
     hitches?: Hitches<TProps, TActions>,
     positractions?: Positractions<TProps>,
     merges?: Merges<TProps>,
+    yields?: Yields<TProps>,
+    /**
+     * Properties to explicitly monitor and propagate changes for.
+     * Use this to ensure getter/setters are installed for properties
+     * that aren't referenced by actions, compacts, merges, etc.
+     * but still need to fire propagator events (e.g., attribute-parsed
+     * properties that other features subscribe to).
+     */
+    propagate?: keyof TProps & string | Array<keyof TProps & string>,
     /**
      * Configure automatic WeakRef wrapping for properties
      * 
@@ -130,7 +163,6 @@ export interface RoundaboutOptions<TProps = unknown, TActions = TProps, ETProps
     vm?: TProps & TActions & RoundaboutReady,
     //for enhanced elements, pass in the container, referenced via $0.
     container?: EventTarget,
-    propagate?: keyof TProps & string | Array<keyof TProps & string>,
     
     //mountObservers?: Set<IMountObserver>
     

package/types/templ-maker/types.d.ts

@@ -0,0 +1,45 @@
+import { SpawnContext } from "../assign-gingerly/types";
+
+/**
+ * Context passed to the TemplateMaker feature constructor
+ */
+export interface FeatureSpawnContext extends SpawnContext {
+    key: string;
+    optIn: any;
+    injection: any;
+    featuresRegistry: any;
+    shared?: any;
+}
+
+/**
+ * Tracks whether the seed DOM fragment came from a shadow root or light DOM children.
+ */
+export type TemplateSource = 'shadow' | 'light';
+
+/**
+ * Properties that the TemplateMaker feature exposes.
+ */
+export interface TemplateMakerProps {
+    /**
+     * The cloned DocumentFragment from the stored template.
+     */
+    clone: DocumentFragment | null;
+}
+
+/**
+ * Internal state
+ */
+export interface AllProps extends TemplateMakerProps {
+    /**
+     * WeakRef to the host custom element
+     */
+    hostRef: WeakRef<Element> | null;
+
+    /**
+     * Whether the template source was shadow DOM or light DOM.
+     */
+    templateSource: TemplateSource | null;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;

package/types/time-ticker/types.d.ts

@@ -0,0 +1,62 @@
+import { SpawnContext } from "../assign-gingerly/types";
+import {FaceUpProps} from "../face-up/types";
+
+/**
+ * Configuration/properties that the TimeTicker feature exposes
+ */
+export interface FeatureProps {
+    /**
+     * Duration in milliseconds between ticks
+     */
+    duration: number;
+
+    /**
+     * Whether the ticker is disabled (stops ticking when true)
+     */
+    disabled: boolean;
+}
+
+/**
+ * Internal state (not exposed to consumers)
+ */
+export interface AllFeatureProps extends FeatureProps {
+    host: WeakRef<Element>;
+}
+
+export type AFP = AllFeatureProps;
+export type PAFP = Partial<AFP>;
+
+/**
+ * Context passed to the feature constructor
+ */
+export interface FeatureSpawnContext extends SpawnContext {
+    key: string;
+    optIn: any;
+    injection: any;
+    featuresRegistry: any;
+    shared?: any;
+}
+
+export interface TimeTickerElementEndUserProps<T = any> extends FaceUpProps {
+    /**
+     * Duration in milliseconds between ticks
+     */
+    duration: number;
+
+    items: T[];
+
+    name: string;
+
+}
+
+export interface TimeTickerElementAllProps<T = any> extends TimeTickerElementEndUserProps{
+    item: T;
+
+    idx: number;
+
+    timeTicker: EventTarget;
+
+    
+}
+
+export type T = TimeTickerElementAllProps;

package/types/truth-sourcer/types.d.ts

@@ -0,0 +1,46 @@
+import { SpawnContext } from "../assign-gingerly/types";
+
+/**
+ * Context passed to the TruthSourcer feature constructor
+ */
+export interface FeatureSpawnContext extends SpawnContext {
+    key: string;
+    optIn: any;
+    injection: any;
+    featuresRegistry: any;
+    shared?: any;
+}
+
+/**
+ * Properties that the TruthSourcer feature manages
+ */
+export interface TruthSourcerProps {
+    /**
+     * The EventTarget that the host element uses to propagate property change events.
+     * TruthSourcer listens for events matching attribute names to sync property -> attribute.
+     */
+    hostPropagator: EventTarget | null;
+}
+
+/**
+ * Internal state
+ */
+export interface AllProps extends TruthSourcerProps {
+    /**
+     * WeakRef to the host custom element
+     */
+    hostRef: WeakRef<HTMLElement> | null;
+
+    /**
+     * The list of observed attribute names (from static observedAttributes)
+     */
+    observedAttributes: string[];
+
+    /**
+     * AbortController for cleaning up event listeners
+     */
+    abortController: AbortController | null;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;