assign-gingerly 0.0.53 → 0.0.55

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

@@ -0,0 +1,22 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface EndUserProps{
+    on: string[];
+    props: 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, ctx: SpawnContext, initVals: PAP): Promise<void>;
+}

package/inferencer/types/data-props/types.d.ts

@@ -0,0 +1,34 @@
+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';
+}
+
+export interface DataPropsParameters {
+    remoteSpecifiers: Array<RemoteSpecifier>;
+}
+
+export interface EndUserProps {
+    parsedStatements: StatementsResult<DataPropsParameters>;
+}
+
+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/do-inc/types.d.ts

@@ -0,0 +1,56 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+import { StatementsResult } from "../nested-regex-groups/types";
+
+export interface EndUserProps{
+    parsedStatements: StatementsResult<IncParameters>,
+}
+
+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{
+    hydrate(self: AP & Actions): ProPAP;
+    handleEvent(self: AP, event: Event, incParameters: IncParameters): void;
+    init(self: AP, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>;
+}
+
+export type asOptions = 
+    | 'number'
+    | 'boolean'
+    | 'string' 
+    | 'object'
+    | 'regexp' 
+    | 'urlpattern'
+    | 'boolean|number'
+;
+
+export type SubPropPath = string;
+export type EventName = string;
+
+// export interface Specifier {
+//     id?: string,
+//     prop?: string,
+//     path?: SubPropPath,
+//     evtName?: EventName,
+//     as?: asOptions,
+//     constVal?: any;
+//     enhKey?: string;
+//     ish?: boolean;
+//     host?: boolean;
+// }
+
+export interface IncParameters {
+    prop?: string | null,
+    byAmtS?: string,
+    byAmtN?: number,
+    targetElementId?: string,
+    localEventType?: string,
+}

package/inferencer/types/do-invoke/types.d.ts

@@ -0,0 +1,38 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+import { StatementsResult } from "../nested-regex-groups/types";
+
+export interface Specifier {
+    selector?: string;
+    prop?: string;
+}
+
+export interface EndUserProps{
+    invokeParamSet: StatementsResult<InvokingParameters>,
+}
+
+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{
+    hydrate(self: AP): ProPAP;
+    init(self: AP, enhancedElement: Element, ctx: SpawnContext, initVals: PAP): Promise<void>
+}
+
+
+
+export interface InvokingParameters {
+    targetSpecifier: {
+        hostOrPeerMethodName: string,
+        targetElementId?: string,
+    },
+    //defaults to "click" if not specified
+    localEventType: string,
+}

package/inferencer/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/inferencer/types/do-toggle/types.d.ts

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

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

@@ -0,0 +1,100 @@
+/**
+ * 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 {
+    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/inferencer/types/fetch-for/types.d.ts

@@ -0,0 +1,36 @@
+import { StatementsResult } from "../nested-regex-groups/types";
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface FetchForParam {
+    remoteSpecifier: {
+        prop?: string;
+        [key: string]: any;
+    };
+}
+
+export interface FetchReadyEvent {
+    url: string;
+    options?: RequestInit;
+}
+
+export interface EndUserProps {
+    fetchForParams: StatementsResult<FetchForParam>;
+}
+
+export interface AllProps extends EndUserProps {
+    enhancedElement: Element;
+    fetchReadyEvent: FetchReadyEvent;
+    resolved: boolean;
+}
+
+export type AP = AllProps;
+
+export type PAP = Partial<AllProps>;
+
+export type ProPAP = Promise<PAP>;
+
+export interface Actions {
+    init(self: AP, enhancedElement: Element & ElementEnhancementGateway, ctx: SpawnContext, initVals: PAP): Promise<void>;
+    hydrate(self: AP): PAP;
+    doFetch(self: AP): Promise<void>;
+}

package/inferencer/types/folder-picker/types.d.ts

@@ -0,0 +1,21 @@
+import { ElementEnhancementGateway, SpawnContext } from "../assign-gingerly/types";
+
+export interface EndUserProps{
+    noNudge: boolean;
+    options: DirectoryPickerOptions;
+}
+
+export interface AllProps extends EndUserProps{
+    enhancedElement: Element;
+    directoryHandle: FileSystemDirectoryHandle | undefined;
+    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/global.d.ts

@@ -0,0 +1,29 @@
+// Type declarations for Map.prototype.getOrInsertComputed and WeakMap.prototype.getOrInsertComputed
+// Feature is now supported in all modern browsers (Chrome 146+, Firefox 134+, Safari 18.2+)
+// See: https://web-platform-dx.github.io/web-features-explorer/features/getorinsert/
+
+interface Map<K, V> {
+  /**
+   * Returns the value associated with the key if it exists, otherwise inserts
+   * the value returned by the insert callback and returns it.
+   * @param key The key to look up
+   * @param insert A callback that returns the value to insert if the key doesn't exist
+   * @returns The existing or newly inserted value
+   */
+  getOrInsertComputed(key: K, insert: () => V): V;
+}
+
+interface WeakMap<K extends object, V> {
+  /**
+   * Returns the value associated with the key if it exists, otherwise inserts
+   * the value returned by the insert callback and returns it.
+   * @param key The key to look up
+   * @param insert A callback that returns the value to insert if the key doesn't exist
+   * @returns The existing or newly inserted value
+   */
+  getOrInsertComputed(key: K, insert: () => V): V;
+}
+
+interface HTMLTemplateElement {
+  remoteContent?: Node;
+}

package/inferencer/types/id-generation/types.d.ts

@@ -0,0 +1,26 @@
+// Type definitions for id-generation
+
+export interface GenIdsOptions {
+    //startCounter?: number;
+}
+
+export interface ParsedDataId {
+    name: string;
+    setName: boolean;
+    setItemprop: boolean;
+    setClass: boolean;
+    setPart: boolean;
+    setItemscope: boolean;
+}
+
+export interface ScopeInfo {
+    scopeElement: Element;
+    elementsToProcess: Element[];
+}
+
+export interface AttributeReplacement {
+    element: Element;
+    attributeName: string;
+    oldValue: string;
+    newValue: string;
+}

package/inferencer/types/inferencer/types.d.ts

@@ -0,0 +1,46 @@
+import type { EnhancementConfig } from "../assign-gingerly/types";
+
+/**
+ * Symbol for smart value assignment
+ */
+export declare const value: symbol;
+
+/**
+ * Symbol for smart display assignment
+ */
+export declare const display: symbol;
+
+/**
+ * Enhancement class that provides smart value and display property inference
+ */
+export declare class Infer<TValue = any, TDisplay = any> {
+    get enhancedElement(): Element;
+    constructor(enhancedElement?: Element);
+    get value(): TValue | undefined;
+    set value(nv: TValue);
+    get display(): TDisplay | undefined;
+    set display(nv: TDisplay);
+    get eventType(): string;
+}
+
+/**
+ * Registry item for the Infer enhancement
+ */
+export declare const registryItem: EnhancementConfig;
+
+/**
+ * Infer the most appropriate value property for an element
+ */
+export declare function inferValueProperty(element: Element): string;
+
+/**
+ * Infer the most appropriate display property for an element
+ */
+export declare function inferDisplayProperty(element: Element): string;
+
+/**
+ * Infer the most appropriate event type for an element
+ */
+export declare function inferEventType(element: Element): string;
+
+export default registryItem;