stimulus-library 0.9.8 → 0.9.10

package/dist/controllers/ajax/async_block_controller.d.ts

@@ -0,0 +1,17 @@
+import { LoadBlockController } from "./load_block_controller";
+export declare class AsyncBlockController extends LoadBlockController {
+    static targets: string[];
+    static values: {
+        endpoint: StringConstructor;
+        errorMessage: StringConstructor;
+        selector: StringConstructor;
+        maxRetries: NumberConstructor;
+    };
+    readonly replaceTarget: HTMLElement;
+    readonly hasReplaceTarget: boolean;
+    readonly endpointValue: string;
+    readonly hasErrorMessageValue: boolean;
+    readonly errorMessageValue: string;
+    get _errorMessage(): string;
+    connect(): Promise<void>;
+}

package/dist/controllers/ajax/index.d.ts

@@ -0,0 +1,4 @@
+export * from './async_block_controller';
+export * from './lazy_block_controller';
+export * from './load_block_controller';
+export * from './poll_block_controller';

package/dist/controllers/ajax/lazy_block_controller.d.ts

@@ -0,0 +1,9 @@
+import { LoadBlockController } from "./load_block_controller";
+export declare class LazyBlockController extends LoadBlockController {
+    observe: () => void;
+    unobserve: () => void;
+    isVisible: boolean;
+    disappear: () => void;
+    connect(): Promise<void>;
+    appear(entry: IntersectionObserverEntry): Promise<void>;
+}

package/dist/controllers/ajax/load_block_controller.d.ts

@@ -0,0 +1,23 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class LoadBlockController extends BaseController {
+    static targets: string[];
+    static values: {
+        endpoint: StringConstructor;
+        errorMessage: StringConstructor;
+        selector: StringConstructor;
+        maxRetries: NumberConstructor;
+    };
+    maxRetriesValue: number;
+    readonly hasMaxRetriesValue: boolean;
+    readonly replaceTarget: HTMLElement;
+    readonly hasReplaceTarget: boolean;
+    readonly endpointValue: string;
+    readonly hasSelectorValue: boolean;
+    readonly selectorValue: string;
+    readonly hasErrorMessageValue: boolean;
+    readonly errorMessageValue: string;
+    get _errorMessage(): string;
+    get _maxRetries(): number;
+    connect(): void;
+    loadContent(event?: Event | null): Promise<void>;
+}

package/dist/controllers/ajax/poll_block_controller.d.ts

@@ -0,0 +1,15 @@
+import { LoadBlockController } from "./load_block_controller";
+export declare class PollBlockController extends LoadBlockController {
+    static targets: string[];
+    static values: {
+        endpoint: StringConstructor;
+        errorMessage: StringConstructor;
+        selector: StringConstructor;
+        maxRetries: NumberConstructor;
+        seconds: NumberConstructor;
+    };
+    readonly hasSecondsValue: boolean;
+    readonly secondsValue: number;
+    connect(): void;
+    _timeout(): Promise<void>;
+}

package/dist/controllers/anchor_spy_controller.d.ts

@@ -0,0 +1,21 @@
+import { BaseController } from "../utilities/base_controller";
+import "../polyfills/string.replaceAll";
+export declare class AnchorSpyController extends BaseController {
+    static values: {
+        key: StringConstructor;
+    };
+    static classes: string[];
+    readonly keyValue: string;
+    addActiveClasses: (el?: HTMLElement) => void;
+    removeInactiveClasses: (el?: HTMLElement) => void;
+    addInactiveClasses: (el?: HTMLElement) => void;
+    removeActiveClasses: (el?: HTMLElement) => void;
+    get defaultActiveClasses(): string[];
+    get defaultInactiveClasses(): string[];
+    get _key(): string;
+    get _anchor(): string;
+    set _anchor(value: string);
+    connect(): void;
+    write(event?: Event): void;
+    private _checkAnchor;
+}

package/dist/controllers/back_link_controller.d.ts

@@ -0,0 +1,16 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class BackLinkController extends BaseController {
+    static values: {
+        timeout: NumberConstructor;
+        pages: NumberConstructor;
+    };
+    readonly timeoutValue: number;
+    readonly hasTimeoutValue: boolean;
+    readonly pagesValue: number;
+    readonly hasPagesValue: boolean;
+    get _pages(): number;
+    get _timeout(): number;
+    connect(): void;
+    goBack(event?: Event): void;
+    fallback(): void;
+}

package/dist/controllers/clipboard_controller.d.ts

@@ -0,0 +1,18 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class ClipboardController extends BaseController {
+    static targets: string[];
+    static values: {
+        removeUnused: BooleanConstructor;
+    };
+    readonly sourceTarget: HTMLElement;
+    readonly copyTarget: HTMLElement;
+    readonly hasCopyTarget: boolean;
+    readonly fallbackTarget: HTMLElement;
+    readonly hasFallbackTarget: boolean;
+    readonly hasRemoveUnusedValue: boolean;
+    readonly removeUnusedValue: boolean;
+    _supported: boolean;
+    connect(): void;
+    select(event: MouseEvent): void;
+    copy(event: ClipboardEvent): void;
+}

package/dist/controllers/confirm_controller.d.ts

@@ -0,0 +1,12 @@
+import { BaseController } from '../utilities/base_controller';
+export declare class ConfirmController extends BaseController {
+    static values: {
+        message: StringConstructor;
+    };
+    readonly messageValue: string;
+    readonly hasMessageValue: boolean;
+    get _message(): string;
+    get _eventType(): "submit" | "click";
+    connect(): void;
+    confirm(event: Event): void;
+}

package/dist/controllers/confirm_navigation_controller.d.ts

@@ -0,0 +1,14 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class ConfirmNavigationController extends BaseController {
+    static values: {
+        message: StringConstructor;
+    };
+    readonly messageValue: string;
+    readonly hasMessageValue: boolean;
+    get _message(): string;
+    connect(): void;
+    disconnect(): void;
+    allowSubmit(_event: Event): void;
+    confirmNavigation(_event: Event | PopStateEvent): boolean;
+    confirmTurboNavigation(event: Event): void;
+}

package/dist/controllers/debug_controller.d.ts

@@ -0,0 +1,6 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class DebugController extends BaseController {
+    static targets: string[];
+    testTargets: HTMLElement[];
+    connect(): void;
+}

package/dist/controllers/disable_with_controller.d.ts

@@ -0,0 +1,19 @@
+import { BaseController } from '../utilities/base_controller';
+export declare class DisableWithController extends BaseController {
+    static values: {
+        message: StringConstructor;
+        timeout: NumberConstructor;
+    };
+    readonly messageValue: string;
+    readonly hasMessageValue: boolean;
+    readonly timeoutValue: number;
+    readonly hasTimeoutValue: boolean;
+    get _message(): string;
+    get _timeout(): number;
+    connect(): void;
+    disable(event?: Event): void;
+    enable(event?: Event): void;
+    _isDisabled(el: HTMLElement): boolean;
+    _disable(): void;
+    _enable(): void;
+}

package/dist/controllers/dismissable_controller.d.ts

@@ -0,0 +1,6 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class DismissableController extends BaseController {
+    dismiss(): void;
+}
+export declare class RemoveController extends DismissableController {
+}

package/dist/controllers/element_save_controller.d.ts

@@ -0,0 +1,30 @@
+import { BaseController } from '../utilities/base_controller';
+import { LocalStorageProxy } from "../mixins";
+export declare class ElementSaveController extends BaseController {
+    static targets: string[];
+    static values: {
+        id: StringConstructor;
+        attributes: StringConstructor;
+        restoreOnLoad: BooleanConstructor;
+    };
+    readonly hasElementTarget: boolean;
+    readonly elementTarget: HTMLElement;
+    readonly elementTargets: HTMLElement[];
+    readonly idValue: string;
+    readonly attributesValue: string;
+    readonly hasIdValue: boolean;
+    readonly restoreOnLoadValue: boolean;
+    readonly hasRestoreOnLoadValue: boolean;
+    _store: LocalStorageProxy<{
+        [idx: string]: string;
+    }>;
+    get _id(): string;
+    get _uniqueIdentifier(): string;
+    get _restoreOnLoad(): boolean;
+    get _element(): HTMLElement;
+    initialize(): void;
+    connect(): void;
+    clear(event?: Event): void;
+    save(event?: Event): void;
+    restore(event?: Event): void;
+}

package/dist/controllers/empty_dom_controller.d.ts

@@ -0,0 +1,21 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class EmptyDomController extends BaseController {
+    static targets: string[];
+    static classes: string[];
+    static values: {
+        scopeSelector: StringConstructor;
+    };
+    readonly hasContainerTarget: boolean;
+    readonly containerTarget: HTMLElement;
+    addEmptyClasses: (el?: HTMLElement) => void;
+    removeEmptyClasses: (el?: HTMLElement) => void;
+    addNotEmptyClasses: (el?: HTMLElement) => void;
+    removeNotEmptyClasses: (el?: HTMLElement) => void;
+    hasScopeSelectorValue: boolean;
+    scopeSelectorValue: string;
+    get _container(): HTMLElement;
+    get _children(): Element[];
+    connect(): void;
+    mutate(entries: MutationRecord[]): void;
+    checkEmpty(): void;
+}

package/dist/controllers/equalize_controller.d.ts

@@ -0,0 +1,15 @@
+import { BaseController } from "../utilities/base_controller";
+export declare class EqualizeController extends BaseController {
+    static targets: string[];
+    readonly watchTargets: HTMLElement[];
+    observer: ResizeObserver;
+    _unobserveIntersection: () => void;
+    initialize(): void;
+    connect(): void;
+    disconnect(): void;
+    watchTargetConnected(element: HTMLElement): void;
+    watchTargetDisconnected(element: HTMLElement): void;
+    appear(_entry: IntersectionObserverEntry): void;
+    _equalize(): void;
+    _unequalize(): void;
+}

package/dist/controllers/forms/auto_submit_form_controller.d.ts

@@ -0,0 +1,22 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class AutoSubmitFormController extends BaseController {
+    static values: {
+        submitMode: StringConstructor;
+        eventMode: StringConstructor;
+        debounceInterval: NumberConstructor;
+    };
+    readonly submitModeValue: "direct" | "request";
+    readonly hasSubmitModeValue: boolean;
+    eventModeValue: 'change' | 'input' | 'debounced';
+    readonly hasEventModeValue: boolean;
+    debounceIntervalValue: number;
+    readonly hasDebounceIntervalValue: boolean;
+    get _eventModes(): Array<'change' | 'input'>;
+    get _debounceTimeout(): number;
+    get _mode(): "direct" | "request";
+    get _cssSelector(): string;
+    get inputElements(): Element[];
+    connect(): void;
+    _ancestorIsTrix(element: Element): boolean;
+    private submit;
+}

package/dist/controllers/forms/autosize_controller.d.ts

@@ -0,0 +1,8 @@
+import { BaseController } from '../../utilities/base_controller';
+export declare class AutosizeController extends BaseController {
+    _unobserveIntersection: () => void;
+    connect(): void;
+    appear(_entry: IntersectionObserverEntry): void;
+    private _handler;
+    private autosize;
+}

package/dist/controllers/forms/char_count_controller.d.ts

@@ -0,0 +1,20 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class CharCountController extends BaseController {
+    static targets: string[];
+    static values: {
+        min: NumberConstructor;
+        max: NumberConstructor;
+    };
+    static classes: string[];
+    readonly inputTarget: HTMLInputElement | HTMLTextAreaElement;
+    readonly outputTarget: HTMLElement;
+    minValue: number;
+    hasMinValue: boolean;
+    maxValue: number;
+    hasMaxValue: boolean;
+    removeErrorClasses: (el?: HTMLElement) => void;
+    addErrorClasses: (el?: HTMLElement) => void;
+    connect(): void;
+    private _updateCharCount;
+    private _isValidCount;
+}

package/dist/controllers/forms/checkbox_disable_inputs_controller.d.ts

@@ -0,0 +1,16 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class CheckboxDisableInputsController extends BaseController {
+    static targets: string[];
+    static values: {
+        clear: BooleanConstructor;
+    };
+    readonly hasDisablerTarget: boolean;
+    readonly disablerTarget: HTMLInputElement;
+    readonly disableTargets: Array<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>;
+    readonly clearValue: boolean;
+    readonly hasClearValue: boolean;
+    connect(): void;
+    toggle(): void;
+    disable(): void;
+    enable(): void;
+}

package/dist/controllers/forms/checkbox_enable_inputs_controller.d.ts

@@ -0,0 +1,16 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class CheckboxEnableInputsController extends BaseController {
+    static targets: string[];
+    static values: {
+        clear: BooleanConstructor;
+    };
+    readonly hasEnablerTarget: boolean;
+    readonly enablerTarget: HTMLInputElement;
+    readonly enableTargets: Array<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>;
+    readonly clearValue: boolean;
+    readonly hasClearValue: boolean;
+    connect(): void;
+    toggle(): void;
+    disable(): void;
+    enable(): void;
+}

package/dist/controllers/forms/checkbox_select_all_controller.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from '../../utilities/base_controller';
+export declare class CheckboxSelectAllController extends BaseController {
+    static targets: string[];
+    readonly hasSelectAllTarget: boolean;
+    readonly selectAllTarget: HTMLInputElement;
+    readonly checkboxTargets: HTMLInputElement[];
+    private get _checked();
+    private get _enabled();
+    private get _unchecked();
+    connect(): void;
+    private _toggle;
+    private _refresh;
+}

package/dist/controllers/forms/checkbox_xor_controller.d.ts

@@ -0,0 +1,8 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class CheckboxXORController extends BaseController {
+    static targets: string[];
+    readonly checkboxTargets: HTMLInputElement[];
+    connect(): void;
+    _otherCheckboxes(el: HTMLInputElement): HTMLInputElement[];
+    _update(event: Event): void;
+}

package/dist/controllers/forms/detect_dirty_controller.d.ts

@@ -0,0 +1,14 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class DetectDirtyController extends BaseController {
+    get _cacheAttrName(): string;
+    connect(): void;
+    restore(event?: Event): void;
+    private _getElementValue;
+    private _getElementLoadValue;
+    private _elementHasCachedLoadValue;
+    private _checkDirty;
+    private _isElementDirty;
+    private _restoreElementFromLoadValue;
+    private _cacheLoadValues;
+}
+export declare function isDirty(element: HTMLElement): boolean;

package/dist/controllers/forms/detect_dirty_form_controller.d.ts

@@ -0,0 +1,17 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class DetectDirtyFormController extends BaseController {
+    get _formElements(): Array<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    get _cacheAttrName(): string;
+    connect(): void;
+    restore(event?: Event): void;
+    private _getElementValue;
+    private _getElementLoadValue;
+    private _elementHasCachedLoadValue;
+    private _checkElementDirty;
+    private _isElementDirty;
+    private _cacheElementLoadValue;
+    private _restoreElementFromLoadValue;
+    private _cacheLoadValues;
+    private _checkDirty;
+}
+export declare function isFormDirty(element: HTMLElement): boolean;

package/dist/controllers/forms/enable_inputs_controller.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class EnableInputsController extends BaseController {
+    static targets: string[];
+    static values: {
+        clear: BooleanConstructor;
+    };
+    readonly inputTargets: Array<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>;
+    readonly clearValue: boolean;
+    readonly hasClearValue: boolean;
+    connect(): void;
+    disable(): void;
+    enable(): void;
+}

package/dist/controllers/forms/focus_steal_controller.d.ts

@@ -0,0 +1,11 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class FocusStealController extends BaseController {
+    static values: {
+        mode: StringConstructor;
+    };
+    modeValue: 'immediate' | 'wait';
+    hasModeValue: boolean;
+    get _mode(): string;
+    connect(): void;
+    steal(): void;
+}

package/dist/controllers/forms/form_rc_controller.d.ts

@@ -0,0 +1,17 @@
+import { BaseController } from '../../utilities/base_controller';
+export declare class FormRcController extends BaseController {
+    static targets: string[];
+    static values: {
+        formSelector: StringConstructor;
+        submitMode: StringConstructor;
+    };
+    submitModeValue: "direct" | "request";
+    readonly hasSubmitModeValue: boolean;
+    readonly formTarget: HTMLFormElement;
+    readonly formSelectorValue: string;
+    readonly hasFormSelectorValue: boolean;
+    get _mode(): "direct" | "request";
+    get form(): HTMLFormElement;
+    submit(event?: Event): void;
+    reset(event?: Event): void;
+}

package/dist/controllers/forms/form_save_controller.d.ts

@@ -0,0 +1,31 @@
+import { BaseController } from '../../utilities/base_controller';
+interface FormSavePayload {
+    [idx: string]: {
+        [idx: string]: string | boolean;
+    };
+}
+export declare class FormSaveController extends BaseController {
+    static values: {
+        id: StringConstructor;
+        restoreOnLoad: BooleanConstructor;
+        clearOnSubmit: BooleanConstructor;
+    };
+    readonly idValue: string;
+    readonly hasIdValue: boolean;
+    readonly restoreOnLoadValue: boolean;
+    readonly hasRestoreOnLoadValue: boolean;
+    readonly clearOnSubmitValue: boolean;
+    readonly hasClearOnSubmitValue: boolean;
+    get _formID(): string;
+    get _formIdentifier(): string;
+    get _formElements(): HTMLFormControlsCollection;
+    get _formData(): FormSavePayload;
+    get _restoreOnLoad(): boolean;
+    get _clearOnSubmit(): boolean;
+    connect(): void;
+    _clear(): void;
+    clear(event?: Event): void;
+    save(event: Event): void;
+    restore(event?: Event): void;
+}
+export {};

package/dist/controllers/forms/index.d.ts

@@ -0,0 +1,22 @@
+export * from './auto_submit_form_controller';
+export * from './autosize_controller';
+export * from './char_count_controller';
+export * from './checkbox_disable_inputs_controller';
+export * from './checkbox_enable_inputs_controller';
+export * from './checkbox_select_all_controller';
+export * from './checkbox_xor_controller';
+export * from './detect_dirty_controller';
+export * from './detect_dirty_form_controller';
+export * from './enable_inputs_controller';
+export * from './focus_steal_controller';
+export * from './form_rc_controller';
+export * from './form_save_controller';
+export * from './limited_selection_checkboxes_controller';
+export * from './navigate_form_errors_controller';
+export * from './nested_form_controller';
+export * from './password_confirm_controller';
+export * from './password_peek_controller';
+export * from './remote_form_controller';
+export * from './sync_inputs_controller';
+export * from './value_warn_controller';
+export * from './word_count_controller';

package/dist/controllers/forms/limited_selection_checkboxes_controller.d.ts

@@ -0,0 +1,16 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class LimitedSelectionCheckboxesController extends BaseController {
+    static targets: string[];
+    static values: {
+        max: NumberConstructor;
+        message: StringConstructor;
+    };
+    readonly hasErrorTarget: boolean;
+    readonly errorTarget: HTMLElement;
+    readonly inputTargets: HTMLInputElement[];
+    readonly maxValue: number;
+    readonly messageValue: string;
+    readonly hasMessageValue: boolean;
+    connect(): void;
+    _handleInputs(event: Event): void;
+}

package/dist/controllers/forms/navigate_form_errors_controller.d.ts

@@ -0,0 +1,40 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class NavigateFormErrorsController extends BaseController {
+    static values: {
+        selector: StringConstructor;
+        index: NumberConstructor;
+    };
+    static classes: string[];
+    static targets: string[];
+    readonly hasNextTarget: boolean;
+    readonly nextTarget: HTMLElement;
+    readonly hasPreviousTarget: boolean;
+    readonly previousTarget: HTMLElement;
+    readonly hasCurrentTarget: boolean;
+    readonly currentTarget: HTMLElement;
+    selectorValue: string;
+    readonly hasSelectorValue: boolean;
+    indexValue: number;
+    readonly hasIndexValue: boolean;
+    _errors: HTMLElement[];
+    _firstClick: boolean;
+    addCurrentClasses: (el?: HTMLElement) => void;
+    removeCurrentClasses: (el?: HTMLElement) => void;
+    get defaultCurrentClasses(): string[];
+    get _errorCount(): number;
+    get _previousIndex(): number;
+    get _nextIndex(): number;
+    get _index(): number;
+    get _selector(): string;
+    get _currentError(): HTMLElement;
+    get _otherErrors(): HTMLElement[];
+    connect(): void;
+    current(event?: Event): Promise<void>;
+    next(event?: Event): Promise<void>;
+    previous(event?: Event): Promise<void>;
+    indexValueChanged(): void;
+    selectorValueChanged(): void;
+    private _updateClasses;
+    private _toggleVisibility;
+    private _toggleButtons;
+}

package/dist/controllers/forms/nested_form_controller.d.ts

@@ -0,0 +1,21 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class NestedFormController extends BaseController {
+    static targets: string[];
+    static values: {
+        insertMode: StringConstructor;
+        wrapperClass: StringConstructor;
+    };
+    readonly targetTarget: HTMLElement;
+    readonly templateTarget: HTMLTemplateElement | HTMLScriptElement;
+    readonly wrapperClassValue: string;
+    readonly hasWrapperSelectorValue: boolean;
+    readonly insertModeValue: InsertPosition;
+    readonly hasInsertModeValue: boolean;
+    get _wrapperClass(): string;
+    get _insertMode(): InsertPosition;
+    connect(): void;
+    add(event?: Event): void;
+    remove(event: Event): void;
+    private _generateID;
+    private _checkStructure;
+}

package/dist/controllers/forms/password_confirm_controller.d.ts

@@ -0,0 +1,11 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class PasswordConfirmController extends BaseController {
+    static targets: string[];
+    static classes: string[];
+    readonly passwordTargets: HTMLInputElement[];
+    addErrorClasses: (el?: HTMLElement) => void;
+    removeErrorClasses: (el?: HTMLElement) => void;
+    connect(): void;
+    private _allPasswordsMatch;
+    private _checkPasswordsMatch;
+}

package/dist/controllers/forms/password_peek_controller.d.ts

@@ -0,0 +1,8 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class PasswordPeekController extends BaseController {
+    static targets: string[];
+    readonly passwordTarget: HTMLInputElement;
+    peak(event?: Event): void;
+    hide(event?: Event): void;
+    toggle(event?: Event): void;
+}

package/dist/controllers/forms/remote_form_controller.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from "../../utilities/base_controller";
+export declare class RemoteFormController extends BaseController {
+    static targets: never[];
+    static values: {
+        selector: StringConstructor;
+    };
+    readonly hasSelectorValue: boolean;
+    readonly selectorValue: string;
+    get _selector(): string;
+    replace(event: {
+        detail: [Element, any, XMLHttpRequest];
+    }): void;
+}