assign-gingerly 0.0.53 → 0.0.55

package/inferencer/types/be-calculating/types.d.ts

@@ -0,0 +1,54 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+import { Infer } from "../inferencer/types";
+
+export interface RemoteSpecifier {
+    id?: string;
+    evtName?: string;
+    prop?: string;
+}
+
+export interface EndUserProps {
+    handler: string;
+    eventArg: string;
+    js: string;
+    format: string;
+    raw: boolean;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element;
+    enhKey: string;
+    enhElLocalName: string;
+    categorized: boolean;
+    forAttr: string;
+    forArgs: string[];
+    handlerObj: EventListenerOrEventListenerObject | Function | undefined;
+    defaultEventType: string;
+    remoteSpecifiers: RemoteSpecifier[];
+    remSpecifierLen: number;
+    isOutputEl: boolean;
+    checkedRegistry: boolean;
+    customHandlers: Map<string, any>;
+    propToInfer: { [key: string]: Infer };
+    notYetParsedJS: boolean;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    categorizeEl(self: AP): PAP;
+    getDefltEvtType(self: AP): PAP;
+    parseForAttr(self: AP): PAP;
+    parseForAttrDSS(self: AP): Promise<PAP>;
+    genRemoteSpecifiers(self: AP): PAP;
+    getEvtHandler(self: AP): PAP;
+    seek(self: AP): Promise<PAP>;
+    hydrate(self: AP): Promise<PAP>;
+    parseJS(self: AP): Promise<PAP>;
+}

package/inferencer/types/be-clonable/types.d.ts

@@ -0,0 +1,38 @@
+export interface EndUserProps{
+    triggerInsertPosition: InsertPosition;
+    cloneInsertPosition: InsertPosition;
+    buttonContent: string;
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    byob?: boolean;
+    trigger: HTMLButtonElement;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface CustomData {
+    triggerSettings: {
+        type: string;
+        '?.classList?.add': string;
+        ariaLabel: string;
+        title: string;
+    },
+    withMethods: string[]
+    
+}
+
+import { SpawnContext } from "../assign-gingerly/types";
+
+export interface Actions{
+    addCloneBtn(self: AP): ProPAP;
+    setBtnContent(self: AP): void;
+    beCloned(self: AP): void;
+    init(self: AP, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>
+}

package/inferencer/types/be-committed/types.d.ts

@@ -0,0 +1,22 @@
+export interface EndUserProps{
+    to: string | undefined;
+    nudge: boolean;
+    on: string;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions{
+    
+    hydrate(self: AP): ProPAP;
+    init(self: AP, enhancedElement: Element, initVals: PAP): Promise<void>
+}

package/inferencer/types/be-consoling/types.d.ts

@@ -0,0 +1,24 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
+
+export interface EndUserProps{
+    level: ConsoleLevel;
+    ignore: string[];
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions{
+    hydrate(self: AP): PAP;
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+}

package/inferencer/types/be-decked-with/types.d.ts

@@ -0,0 +1,26 @@
+
+export interface EndUserProps{
+    path: string
+    src: string
+}
+
+export interface AllProps extends EndUserProps{
+    template: HTMLTemplateElement;
+    enhancedElement: Element;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+//export type BAP = AP & BEAllProps;
+
+export interface Actions{
+    act(self: BAP): PAP
+    fetchRemoteTemplate(self: BAP): ProPAP
+    upShadowSearch(self: BAP): ProPAP
+    init(self: BAP, initVals: PAP): Promise<void>
+}

package/inferencer/types/be-delible/types.d.ts

@@ -0,0 +1,27 @@
+export interface EndUserProps{
+    triggerInsertPosition: InsertPosition;
+    buttonContent: string;
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    byob?: boolean,
+    trigger: HTMLButtonElement;
+    resolved: boolean,
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface Actions{
+    
+    addDeleteBtn(self: AP): ProPAP ;
+    setBtnContent(self: AP): void;
+    beDeleted(self: AP): void;
+    init(self: AP & Actions, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+}

package/inferencer/types/be-dispatching/types.d.ts

@@ -0,0 +1,34 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+import { StatementsResult } from "../nested-regex-groups/types";
+
+export interface DispatchRule {
+    dispatch: string;
+    dispatchOn?: string;
+    qualifiers?: string;
+    bubbles?: boolean;
+    composed?: boolean;
+    cancelable?: boolean;
+    replace?: boolean;
+}
+
+export interface EndUserProps {
+    crudeDispatchRules: StatementsResult<DispatchRule>;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element;
+    dispatchRules: Array<DispatchRule>;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    finishParsing(self: AP): PAP;
+    hydrate(self: AP): ProPAP;
+}

package/inferencer/types/be-evanescent/types.d.ts

@@ -0,0 +1,20 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface EndUserProps{
+    whenDefined: string[];
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;
+export type ProPAP = Promise<PAP>;
+
+export interface Actions{
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    inferFromParent(self: AP): ProPAP;
+    onWhenDefined(self: AP): ProPAP;
+}

package/inferencer/types/be-flashy/types.d.ts

@@ -0,0 +1,21 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface EndUserProps{
+    duration: number;
+    attr: string;
+    css: string;
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;
+export type ProPAP = Promise<PAP>;
+
+export interface Actions{
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    hydrate(self: AP): ProPAP;
+}

package/inferencer/types/be-gone/types.d.ts

@@ -0,0 +1,25 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface EndUserProps {
+    whenDef: string;
+    whenMissing: string;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element;
+    onDefined: string[];
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    parseWhenDef(self: AP): PAP;
+    onOnDefined(self: AP): ProPAP;
+    hydrateOnMissing(self: AP): ProPAP;
+}

package/inferencer/types/be-observing/types.d.ts

@@ -0,0 +1,55 @@
+import { StatementsResult } from "../nested-regex-groups/types";
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface RemoteSpecifier {
+    id?: string;
+    prop?: string;
+    path?: string;
+    evtName?: string;
+    as?: 'number' | 'boolean' | 'string' | 'object' | 'regexp' | 'urlpattern' | 'boolean|number';
+    constVal?: any;
+    enhKey?: string;
+    ish?: boolean;
+    host?: boolean;
+    self?: boolean;
+}
+
+export interface ObservingParameters {
+    localPropToSet?: string;
+    remoteSpecifiers: Array<RemoteSpecifier>;
+    punt: boolean;
+    aggKey: string;
+    interpolatingExpr: string;
+    JSExpr: string;
+    ONExpr: string;
+    action?:
+        | 'set'
+        | 'toggle'
+        | 'increment'
+        | 'decrement'
+        | 'set-class'
+        | 'set-part';
+}
+
+export interface EndUserProps {
+    parsedStatements: StatementsResult<ObservingParameters>;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element;
+    enhKey: string;
+    customHandlers: Map<string, any>;
+    ws: Array<any>;
+    didInferring: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    seek(self: AP): ProPAP;
+}

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

@@ -0,0 +1,78 @@
+/**
+ * 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 {
+    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/inferencer/types/be-reformable/types.d.ts

@@ -0,0 +1,49 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface SubmitOptions {
+    onlyAfter: string,
+    nudges: boolean,
+    disableIfNotAllConditionsAreMet: boolean
+}
+
+export interface EndUserProps{
+    baseLink: string,
+    baseURL: string,
+    path: string,
+    headers: HeadersInit | undefined,
+    updateOn: 'input' | 'change' | 'submit',
+    submitOptions: SubmitOptions,
+    headerFields: Array<string>
+}
+
+type BeforeToken = string;
+type TokenKey = string | undefined
+
+export interface IURLBuilder{
+    readonly tokens: Array<[BeforeToken, TokenKey]>
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    updateCnt: number,
+    readonly urlBuilder: IURLBuilder,
+    readonly resolvedBaseURL: true,
+    readonly fetchOptions: RequestInit,
+    readonly isFetchReady: boolean,
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    resolveBaseLink(self: AP): PAP;
+    specifyDefaultBaseURL(self: AP): PAP;
+    hydrate(self: AP): ProPAP;
+    updateAction(self: AP): ProPAP;
+    parsePath(self: AP): ProPAP;
+    suggestFetch(self: AP): ProPAP;
+}

package/inferencer/types/be-render-neutral/types.d.ts

@@ -0,0 +1,32 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface RenderingHTMLScriptElement extends HTMLScriptElement{
+    renderer: (vm: any, html: any) => any,
+}
+
+export interface EndUserProps{
+    vm: any,
+    with: Array<string>,
+}
+
+export type Renderer = (vm: any, html: any) => any;
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    renderer: Renderer,
+    absorbingObject: any
+}
+
+export type PAP = Partial<AllProps>;
+
+export type AP = AllProps;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    getRenderer(self: AP): PAP;
+    doRender(self: AP): void;
+    observe(self: AP): ProPAP;
+    absorb(self: AP, e?: Event): ProPAP;
+}

package/inferencer/types/be-switched/types.d.ts

@@ -0,0 +1,146 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+import { StatementsResult } from "../nested-regex-groups/types";
+
+/**
+ * Parsed specifier for referencing an element's value
+ */
+export interface ValueSpecifier {
+    /** Element ID (without #) */
+    id?: string;
+    /** Property name to observe */
+    prop?: string;
+    /** Property path (chained accessor) */
+    path?: string;
+    /** Event name to listen for changes */
+    evtName?: string;
+    /** Attribute name (source of truth) */
+    attr?: string;
+    /** Constant value (backtick-delimited) */
+    constVal?: string;
+    /** Type casting */
+    as?: 'number' | 'string' | 'boolean';
+}
+
+/**
+ * A two-value comparison statement (lhs op rhs)
+ */
+export interface TwoValueSwitch {
+    onOrOff: 'on' | 'off';
+    lhsSpecifier: ValueSpecifier;
+    rhsSpecifier: ValueSpecifier;
+    op: 'eq' | 'equals' | 'lt' | 'gt' | 'lte' | 'gte';
+    /** Required (AND) condition */
+    req?: boolean;
+}
+
+/**
+ * A single boolean value switch
+ */
+export interface SingleValSwitch {
+    onOrOff: 'on' | 'off';
+    specifier: ValueSpecifier;
+    /** Required (AND / "only") condition */
+    req?: boolean;
+}
+
+/**
+ * An n-value JavaScript-evaluated switch
+ */
+export interface NValueSwitch {
+    dependencies: ValueSpecifier[];
+    registeredHandler?: string;
+}
+
+/**
+ * Parsed result from the DSL attribute
+ */
+export interface ParsedStatements {
+    twoValueSwitches?: TwoValueSwitch[];
+    singleValSwitches?: SingleValSwitch[];
+    nValueSwitches?: NValueSwitch[];
+}
+
+export interface EndUserProps {
+    /** Type casting for comparisons */
+    as?: 'number' | 'string' | 'boolean';
+    /** Use view transitions */
+    transitional?: boolean;
+    /** Delete content when invalid instead of hiding */
+    minMem?: boolean;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element & ElementEnhancementGateway;
+    /** Raw parsed statements from the DSL */
+    parsedStatements: StatementsResult<ParsedStatements>;
+    /** The JS expression for CSP-safe evaluation */
+    js?: string;
+    /** Whether the JS expression has been processed */
+    notProcessedJS: boolean;
+    /** Hidden style rule */
+    hiddenStyle: string;
+    /** Whether to use boolish comparison */
+    beBoolish: boolean;
+    /** Simple lhs value (Part I JSON mode) */
+    lhs: any;
+    /** Simple rhs value (Part I JSON mode) */
+    rhs: any;
+    /** Computed final value (true = show content) */
+    val: boolean;
+    /** Echo of val for change detection */
+    echoVal: boolean;
+    /** Combined satisfaction of all switches */
+    switchesSatisfied: boolean;
+    /** Single val switches are satisfied */
+    singleValSwitchesSatisfied: boolean;
+    /** Single val switch veto */
+    singleValSwitchNoGo: boolean;
+    /** Two val switches are satisfied */
+    twoValSwitchesSatisfied: boolean;
+    /** Two val switch veto */
+    twoValSwitchNoGo: boolean;
+    /** ID ref attribute for tracking cloned content */
+    idRefAttr: string;
+    /** Toggle inert on hide */
+    toggleInert?: boolean;
+    /** EMC config reference */
+    emc: any;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+export type PAP = Partial<AP>;
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    hydrate(self: AP): ProPAP;
+    onTrue(self: AP): Promise<void>;
+    onFalse(self: AP): Promise<void>;
+    calcVal(self: AP): PAP;
+    calcSwitchesSatisfied(self: AP): PAP;
+    onSingleValSwitches(self: AP): Promise<void>;
+    onTwoValSwitches(self: AP): Promise<void>;
+    onNValSwitches(self: AP): Promise<void>;
+    processJS(self: AP): ProPAP;
+}
+
+/**
+ * Event passed to registered n-value handlers.
+ * Handlers set `e.r` to the result of their evaluation.
+ */
+export interface AggEvent extends Event {
+    /** The return value — set this to the result of the evaluation */
+    r: any;
+    /** Array of dependency values in declaration order */
+    args: Array<any>;
+    /** Named map of dependency values (keyed by data-id, id, or prop name) */
+    f: { [key: string]: any };
+    /** The enhanced element (template or data) */
+    target: EventTarget;
+}
+
+/**
+ * Handler function signature for registered n-value handlers
+ */
+export type AggHandler = (e: AggEvent) => void;

package/inferencer/types/be-typed/types.d.ts

@@ -0,0 +1,32 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface EndUserProps {
+    triggerInsertPosition: InsertPosition;
+    labelTextContainer: string;
+    buttonContent: string;
+    nudge?: boolean;
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    byob?: boolean;
+    trigger: WeakRef<HTMLButtonElement>
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AP>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions{
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    addTypeBtn(self: AP): ProPAP;
+    setBtnContent(self: AP): void;
+    openDialog(self: AP): Promise<void>
+}
+
+export interface ITyper{
+    showDialog(): void;
+    dispose(): void;
+}