el-maker 0.0.0 → 0.0.1

package/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/types/be-render-neutral/types.d.ts

@@ -0,0 +1,29 @@
+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 {
+    getRenderer(self: AP): PAP;
+    doRender(self: AP): void;
+    observe(self: AP): ProPAP;
+    absorb(self: AP, e?: Event): ProPAP;
+}

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

@@ -0,0 +1,31 @@
+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{
+    addTypeBtn(self: AP): ProPAP;
+    setBtnContent(self: AP): void;
+    openDialog(self: AP): Promise<void>
+}
+
+export interface ITyper{
+    showDialog(): void;
+    dispose(): void;
+}

package/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/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/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

@@ -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/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/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/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/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;