@pechynho/stimulus-typescript 0.0.8

package/dist/portal.d.ts

@@ -0,0 +1,13 @@
+import { Controller } from "@hotwired/stimulus";
+import Portal from "./portal-controller";
+type Constructor<T = {}> = new (...args: any[]) => T;
+export declare function Portals<Base extends Constructor<Controller>>(Base: Base): typeof Base & {
+    new (...args: any[]): InstanceType<Base> & {
+        readonly portalOutlet: Portal;
+        readonly hasPortalOutlet: boolean;
+        readonly portalOutlets: Portal[];
+        portalSelectorsValue: string[];
+        readonly hasPortalSelectorsValue: boolean;
+    };
+};
+export {};

package/dist/portal.js

@@ -0,0 +1,101 @@
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+export function Portals(Base) {
+    var _a;
+    let outlets = Base.outlets;
+    if (typeof outlets === 'undefined') {
+        outlets = [];
+    }
+    else if (!Array.isArray(outlets)) {
+        throw new Error('Outlets must be an array');
+    }
+    if (!outlets.includes('portal')) {
+        outlets.push('portal');
+    }
+    let values = Base.values;
+    if (typeof values === 'undefined') {
+        values = {};
+    }
+    else if (typeof values !== 'object') {
+        throw new Error('Values must be an object');
+    }
+    if (typeof values['portalSelectors'] === 'undefined') {
+        values['portalSelectors'] = {
+            type: Array,
+            default: [],
+        };
+    }
+    const derived = (_a = class extends Base {
+            constructor(...args) {
+                super(...args);
+                const portalOutlets = new Set();
+                const originalDisconnect = this.disconnect;
+                this.disconnect = function () {
+                    if (portalOutlets.size > 0) {
+                        for (const outlet of portalOutlets) {
+                            outlet.unsync(this);
+                        }
+                        portalOutlets.clear();
+                    }
+                    if (typeof originalDisconnect === 'function') {
+                        originalDisconnect.call(this);
+                    }
+                };
+                const originalPortalOutletConnected = this.portalOutletConnected;
+                this.portalOutletConnected = function (outlet, element) {
+                    outlet.sync(this);
+                    portalOutlets.add(outlet);
+                    if (typeof originalPortalOutletConnected === 'function') {
+                        originalPortalOutletConnected.call(this, outlet, element);
+                    }
+                };
+                const originalPortalOutletDisconnected = this.portalOutletDisconnected;
+                this.portalOutletDisconnected = function (outlet, element) {
+                    outlet.unsync(this);
+                    portalOutlets.delete(outlet);
+                    if (typeof originalPortalOutletDisconnected === 'function') {
+                        originalPortalOutletDisconnected.call(this, outlet, element);
+                    }
+                };
+                const originalPortalSelectorsValueChanged = this.portalSelectorsValueChanged;
+                this.portalSelectorsValueChanged = function (value, previousValue) {
+                    const outletAttribute = `data-${this.identifier}-portal-outlet`;
+                    if (value.length > 0) {
+                        const controllerAttribute = this.context.schema.controllerAttribute;
+                        const selector = value.join(', ');
+                        const portalElements = document.querySelectorAll(selector);
+                        for (const portalElement of portalElements) {
+                            if (!portalElement.hasAttribute(controllerAttribute)) {
+                                portalElement.setAttribute(controllerAttribute, 'portal');
+                                continue;
+                            }
+                            const existingControllers = portalElement.getAttribute(controllerAttribute).split(' ');
+                            if (!existingControllers.includes('portal')) {
+                                existingControllers.push('portal');
+                                portalElement.setAttribute(controllerAttribute, existingControllers.join(' '));
+                            }
+                        }
+                        if (!this.element.hasAttribute(outletAttribute)) {
+                            this.element.setAttribute(outletAttribute, selector);
+                        }
+                        else if (this.element.getAttribute(outletAttribute) !== selector) {
+                            this.element.setAttribute(outletAttribute, selector);
+                        }
+                    }
+                    else if (this.element.hasAttribute(outletAttribute)) {
+                        this.element.removeAttribute(outletAttribute);
+                    }
+                    if (typeof originalPortalSelectorsValueChanged === 'function') {
+                        originalPortalSelectorsValueChanged.call(this, value, previousValue);
+                    }
+                };
+            }
+        },
+        __setFunctionName(_a, "derived"),
+        _a.outlets = outlets,
+        _a.values = values,
+        _a);
+    return derived;
+}

package/dist/resolvable.d.ts

@@ -0,0 +1,28 @@
+import { Application, Controller } from "@hotwired/stimulus";
+type Constructor<T = {}> = new (...args: any[]) => T;
+export declare function Resolvable<Base extends Constructor<Controller>>(Base: Base, identifier: string): {
+    new (...args: any[]): {
+        readonly context: import("@hotwired/stimulus").Context;
+        get application(): Application;
+        get scope(): import("@hotwired/stimulus/dist/types/core/scope").Scope;
+        get element(): Element;
+        get identifier(): string;
+        get targets(): import("@hotwired/stimulus/dist/types/core/target_set").TargetSet;
+        get outlets(): import("@hotwired/stimulus/dist/types/core/outlet_set").OutletSet;
+        get classes(): import("@hotwired/stimulus/dist/types/core/class_map").ClassMap;
+        get data(): import("@hotwired/stimulus/dist/types/core/data_map").DataMap;
+        initialize(): void;
+        connect(): void;
+        disconnect(): void;
+        dispatch(eventName: string, { target, detail, prefix, bubbles, cancelable, }?: Partial<{
+            target: Element | Window | Document;
+            detail: Object;
+            prefix: string;
+            bubbles: boolean;
+            cancelable: boolean;
+        }>): CustomEvent<Object>;
+    };
+    get<T extends Constructor<Controller>>(this: T, element: HTMLElement): InstanceType<T> | null;
+    getAsync<T extends Constructor<Controller>>(this: T, element: HTMLElement, timeout?: number, poll?: number): Promise<InstanceType<T> | null>;
+} & Base;
+export {};

package/dist/resolvable.js

@@ -0,0 +1,54 @@
+import { getController, getControllerAsync } from "./utils";
+const identifierToAppMap = new Map();
+export function Resolvable(Base, identifier) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+            const originalConnect = this.connect;
+            this.connect = function () {
+                identifierToAppMap.set(this.identifier, this.application);
+                if (typeof originalConnect === 'function') {
+                    originalConnect.call(this);
+                }
+            };
+        }
+        static get(element) {
+            const app = identifierToAppMap.get(identifier);
+            if (typeof app === 'undefined') {
+                return null;
+            }
+            return getController(app, element, identifier);
+        }
+        static getAsync(element, timeout = 5000, poll = 50) {
+            const app = identifierToAppMap.get(identifier);
+            if (typeof app !== 'undefined') {
+                return getControllerAsync(app, element, identifier, timeout, poll);
+            }
+            const startTime = Date.now();
+            const maxAttempts = 10;
+            let attempts = 0;
+            return new Promise((resolve) => {
+                const checkApp = async () => {
+                    attempts++;
+                    const app = identifierToAppMap.get(identifier);
+                    if (typeof app !== 'undefined') {
+                        const remainingTime = timeout - (Date.now() - startTime);
+                        remainingTime <= 0
+                            ? resolve(getController(app, element, identifier))
+                            : resolve(await getControllerAsync(app, element, identifier, remainingTime, poll));
+                    }
+                    else if (Date.now() - startTime >= timeout) {
+                        resolve(null);
+                    }
+                    else if (attempts <= maxAttempts) {
+                        setTimeout(checkApp);
+                    }
+                    else {
+                        setTimeout(checkApp, poll);
+                    }
+                };
+                checkApp().catch(error => console.error(error));
+            });
+        }
+    };
+}

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,56 @@
+import { Controller } from '@hotwired/stimulus';
+import { Target, Typed, TypedArray, TypedObject } from './index';
+import { Portals } from "./portal";
+import { Resolvable } from "./resolvable";
+class OutletController extends Typed(Controller) {
+    method() {
+    }
+}
+class HomepageController extends Typed(Portals(Resolvable((Controller), 'homepage')), {
+    values: {
+        name: String,
+        counter: Number,
+        isActive: Boolean,
+        alias: TypedArray(),
+        address: TypedObject(),
+        metadata: { type: TypedObject() },
+    },
+    targets: {
+        form: HTMLFormElement,
+        select: HTMLSelectElement,
+        custom: Target(),
+    },
+    classes: ['selected', 'highlighted'],
+    outlets: {
+        'test': OutletController,
+    },
+}) {
+    // All properties are now strongly typed!
+    connect() {
+        // String values
+        this.nameValue.split(' ');
+        // Number values
+        Math.floor(this.counterValue);
+        // Boolean values
+        this.isActiveValue;
+        // Array values
+        this.aliasValue.map(alias => alias.toUpperCase());
+        // Object values
+        console.log(this.addressValue.street);
+        console.log(this.metadataValue.title);
+        // Targets
+        this.formTarget.submit();
+        this.selectTarget.value = 'stimulus';
+        this.customTarget.someCustomMethod();
+        // Outlets
+        this.testOutlet.method();
+        // Classes
+        if (this.hasSelectedClass) {
+            console.log(this.selectedClass);
+        }
+        // Portals
+        if (this.hasPortalOutlet) {
+            console.log(this.portalOutlet);
+        }
+    }
+}

package/dist/typed-stimulus.d.ts

@@ -0,0 +1,78 @@
+import { Controller } from "@hotwired/stimulus";
+import Portal from "./portal-controller";
+declare class Wrapped<T = any> {
+    readonly context: 'typed-object' | 'typed-array' | 'target';
+    private _;
+    constructor(context: 'typed-object' | 'typed-array' | 'target');
+}
+export declare const TypedObject: <T extends object>() => Wrapped<T>;
+export declare const TypedArray: <T>() => Wrapped<T[]>;
+export declare const Target: <T extends object>() => Wrapped<T>;
+type Constructor<T = {}> = new (...args: any[]) => T;
+type CamelCase<K extends string> = K extends `${infer T}_${infer U}` ? `${Uncapitalize<T>}${Capitalize<CamelCase<U>>}` : K extends `${infer T}-${infer U}` ? `${Uncapitalize<T>}${Capitalize<CamelCase<U>>}` : K extends `${infer T} ${infer U}` ? `${Uncapitalize<T>}${Capitalize<CamelCase<U>>}` : K;
+type ClassProperties<Classes extends readonly string[] = []> = {
+    [K in Classes[number] as `${CamelCase<K>}Class`]: string;
+} & {
+    readonly [K in Classes[number] as `has${Capitalize<CamelCase<K>>}Class`]: boolean;
+} & {
+    [K in Classes[number] as `${CamelCase<K>}Classes`]: string[];
+};
+type ValueTypeDefault = string | number | boolean | Array<any> | Object | InstanceType<typeof Wrapped>;
+type ValueTypeConstant = typeof String | typeof Number | typeof Boolean | typeof Array<any> | typeof Object | InstanceType<typeof Wrapped>;
+type ValueTypeObject = {
+    type: ValueTypeConstant;
+    default?: ValueTypeDefault;
+};
+type ValueTypeDefinition = ValueTypeConstant | ValueTypeObject | InstanceType<typeof Wrapped>;
+type ValueDefinitionMap = {
+    [token: string]: ValueTypeDefinition;
+};
+type TypeFromConstructor<C> = C extends StringConstructor ? string : C extends NumberConstructor ? number : C extends BooleanConstructor ? boolean : C extends ArrayConstructor ? any[] : C extends Wrapped<infer T> ? T : C extends ObjectConstructor ? Object : C extends Constructor<infer T> ? TypeFromConstructor<T> : never;
+type TransformValueDefinition<T extends ValueTypeDefinition> = T extends {
+    type: infer U;
+} ? TypeFromConstructor<U> : TypeFromConstructor<T>;
+type ValuesProperties<Values extends ValueDefinitionMap> = {
+    [K in keyof Values as `${CamelCase<K & string>}Value`]: TransformValueDefinition<Values[K]>;
+} & {
+    readonly [K in keyof Values as `has${Capitalize<CamelCase<K & string>>}Value`]: boolean;
+};
+type TargetTypeDefinition = typeof Element | InstanceType<typeof Wrapped>;
+type TargetsDefinitionMap = {
+    [token: string]: TargetTypeDefinition;
+};
+type TransformTargetDefinition<T extends TargetTypeDefinition> = T extends Wrapped<infer U> ? U : T extends new (...args: any[]) => infer R ? R : never;
+type TargetsProperties<Targets extends TargetsDefinitionMap> = {
+    readonly [K in keyof Targets as `${CamelCase<K & string>}Target`]: TransformTargetDefinition<Targets[K]>;
+} & {
+    readonly [K in keyof Targets as `has${Capitalize<CamelCase<K & string>>}Target`]: boolean;
+} & {
+    readonly [K in keyof Targets as `${CamelCase<K & string>}Targets`]: TransformTargetDefinition<Targets[K]>[];
+};
+type OutletsDefinitionMap = {
+    [token: string]: Constructor<Controller>;
+};
+type OutletProperties<Outlets extends OutletsDefinitionMap> = {
+    readonly [K in keyof Outlets as `${CamelCase<K & string>}Outlet`]: InstanceType<Outlets[K]>;
+} & {
+    readonly [K in keyof Outlets as `has${Capitalize<CamelCase<K & string>>}Outlet`]: boolean;
+} & {
+    readonly [K in keyof Outlets as `${CamelCase<K & string>}Outlets`]: InstanceType<Outlets[K]>[];
+};
+type PortalProperties<Portals extends true | undefined> = Portals extends boolean ? {
+    readonly portalOutlet: Portal;
+    readonly hasPortalOutlet: boolean;
+    readonly portalOutlets: Portal[];
+    portalSelectorsValue: string[];
+    readonly hasPortalSelectorsValue: boolean;
+} : {};
+type Configuration<Values extends ValueDefinitionMap, Targets extends TargetsDefinitionMap, Classes extends readonly string[], Outlets extends OutletsDefinitionMap, Portals extends true | undefined> = {
+    values?: Values;
+    targets?: Targets;
+    classes?: Classes;
+    outlets?: Outlets;
+    portals?: Portals;
+};
+export declare function Typed<Base extends Constructor<Controller>, Values extends ValueDefinitionMap = {}, Targets extends TargetsDefinitionMap = {}, Classes extends readonly string[] = [], Outlets extends OutletsDefinitionMap = {}, Portals extends true | undefined = undefined>(Base: Base, configuration?: Configuration<Values, Targets, Classes, Outlets, Portals>): typeof Base & {
+    new (...any: any[]): InstanceType<Base> & ValuesProperties<Values> & TargetsProperties<Targets> & ClassProperties<Classes> & OutletProperties<Outlets> & PortalProperties<Portals>;
+};
+export {};

package/dist/typed-stimulus.js

@@ -0,0 +1,139 @@
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+class Wrapped {
+    constructor(context) {
+        this.context = context;
+        this._ = undefined;
+    }
+}
+export const TypedObject = () => new Wrapped('typed-object');
+export const TypedArray = () => new Wrapped('typed-array');
+export const Target = () => new Wrapped('target');
+function PortalsMixin(Base) {
+    return class extends Base {
+        constructor(...any) {
+            super(...any);
+            const portalOutlets = new Set();
+            const originalDisconnect = this.disconnect;
+            this.disconnect = function () {
+                if (portalOutlets.size > 0) {
+                    for (const outlet of portalOutlets) {
+                        outlet.unsync(this);
+                    }
+                    portalOutlets.clear();
+                }
+                if (typeof originalDisconnect === 'function') {
+                    originalDisconnect.call(this);
+                }
+            };
+            const originalPortalOutletConnected = this.portalOutletConnected;
+            this.portalOutletConnected = function (outlet, element) {
+                outlet.sync(this);
+                portalOutlets.add(outlet);
+                if (typeof originalPortalOutletConnected === 'function') {
+                    originalPortalOutletConnected.call(this, outlet, element);
+                }
+            };
+            const originalPortalOutletDisconnected = this.portalOutletDisconnected;
+            this.portalOutletDisconnected = function (outlet, element) {
+                outlet.unsync(this);
+                portalOutlets.delete(outlet);
+                if (typeof originalPortalOutletDisconnected === 'function') {
+                    originalPortalOutletDisconnected.call(this, outlet, element);
+                }
+            };
+            const originalPortalSelectorsValueChanged = this.portalSelectorsValueChanged;
+            this.portalSelectorsValueChanged = function (value, previousValue) {
+                const outletAttribute = `data-${this.identifier}-portal-outlet`;
+                if (value.length > 0) {
+                    const controllerAttribute = this.context.schema.controllerAttribute;
+                    const selector = value.join(', ');
+                    const portalElements = document.querySelectorAll(selector);
+                    for (const portalElement of portalElements) {
+                        if (!portalElement.hasAttribute(controllerAttribute)) {
+                            portalElement.setAttribute(controllerAttribute, 'portal');
+                            continue;
+                        }
+                        const existingControllers = portalElement.getAttribute(controllerAttribute).split(' ');
+                        if (!existingControllers.includes('portal')) {
+                            existingControllers.push('portal');
+                            portalElement.setAttribute(controllerAttribute, existingControllers.join(' '));
+                        }
+                    }
+                    if (!this.element.hasAttribute(outletAttribute)) {
+                        this.element.setAttribute(outletAttribute, selector);
+                    }
+                    else if (this.element.getAttribute(outletAttribute) !== selector) {
+                        this.element.setAttribute(outletAttribute, selector);
+                    }
+                }
+                else if (this.element.hasAttribute(outletAttribute)) {
+                    this.element.removeAttribute(outletAttribute);
+                }
+                if (typeof originalPortalSelectorsValueChanged === 'function') {
+                    originalPortalSelectorsValueChanged.call(this, value, previousValue);
+                }
+            };
+        }
+    };
+}
+function patchValueTypeDefinitionMap(values) {
+    const patchedValues = {};
+    const patchType = (type) => {
+        if (type instanceof Wrapped && type.context === 'typed-object') {
+            return Object;
+        }
+        if (type instanceof Wrapped && type.context === 'typed-array') {
+            return Array;
+        }
+        return type;
+    };
+    Object.getOwnPropertyNames(values).forEach(key => {
+        const definition = values[key];
+        if (typeof definition === 'object' && 'default' in definition && 'type' in definition) {
+            patchedValues[key] = {
+                type: patchType(definition.type),
+                default: definition.default,
+            };
+        }
+        else if (typeof definition === 'object' && 'type' in definition) {
+            patchedValues[key] = patchType(definition.type);
+        }
+        else if (definition instanceof Wrapped) {
+            patchedValues[key] = patchType(definition);
+        }
+        else {
+            patchedValues[key] = definition;
+        }
+    });
+    return patchedValues;
+}
+export function Typed(Base, configuration) {
+    var _a;
+    const { values, targets, classes, outlets, portals } = configuration !== null && configuration !== void 0 ? configuration : {};
+    const patchedOutlet = Object.getOwnPropertyNames(outlets !== null && outlets !== void 0 ? outlets : {});
+    const patchedValues = patchValueTypeDefinitionMap(values !== null && values !== void 0 ? values : {});
+    if (portals === true) {
+        patchedOutlet.push('portal');
+        if (typeof patchedValues['portalSelectors'] === 'undefined') {
+            patchedValues['portalSelectors'] = { type: TypedArray(), default: [] };
+        }
+    }
+    let derived = (_a = class extends Base {
+            constructor(...any) {
+                super(...any);
+            }
+        },
+        __setFunctionName(_a, "derived"),
+        _a.values = patchedValues,
+        _a.targets = Object.getOwnPropertyNames(targets !== null && targets !== void 0 ? targets : {}),
+        _a.classes = classes !== null && classes !== void 0 ? classes : [],
+        _a.outlets = patchedOutlet,
+        _a);
+    if (portals === true) {
+        derived = PortalsMixin(derived);
+    }
+    return derived;
+}

package/dist/typed.d.ts

@@ -0,0 +1,69 @@
+import { Controller } from "@hotwired/stimulus";
+declare class Wrapped<T = any> {
+    readonly context: 'typed-object' | 'typed-array' | 'target';
+    private _;
+    constructor(context: 'typed-object' | 'typed-array' | 'target');
+}
+export declare const TypedObject: <T extends object>() => Wrapped<T>;
+export declare const TypedArray: <T>() => Wrapped<T[]>;
+export declare const Target: <T extends object>() => Wrapped<T>;
+type Constructor<T = {}> = new (...args: any[]) => T;
+type CamelCase<K extends string> = K extends `${infer T}_${infer U}` ? `${Uncapitalize<T>}${Capitalize<CamelCase<U>>}` : K extends `${infer T}-${infer U}` ? `${Uncapitalize<T>}${Capitalize<CamelCase<U>>}` : K extends `${infer T} ${infer U}` ? `${Uncapitalize<T>}${Capitalize<CamelCase<U>>}` : K;
+type ClassProperties<Classes extends readonly string[] = []> = {
+    [K in Classes[number] as `${CamelCase<K>}Class`]: string;
+} & {
+    readonly [K in Classes[number] as `has${Capitalize<CamelCase<K>>}Class`]: boolean;
+} & {
+    [K in Classes[number] as `${CamelCase<K>}Classes`]: string[];
+};
+type ValueTypeDefault = string | number | boolean | Array<any> | Object | InstanceType<typeof Wrapped>;
+type ValueTypeConstant = typeof String | typeof Number | typeof Boolean | typeof Array<any> | typeof Object | InstanceType<typeof Wrapped>;
+type ValueTypeObject = {
+    type: ValueTypeConstant;
+    default?: ValueTypeDefault;
+};
+type ValueTypeDefinition = ValueTypeConstant | ValueTypeObject | InstanceType<typeof Wrapped>;
+type ValueDefinitionMap = {
+    [token: string]: ValueTypeDefinition;
+};
+type TypeFromConstructor<C> = C extends StringConstructor ? string : C extends NumberConstructor ? number : C extends BooleanConstructor ? boolean : C extends ArrayConstructor ? any[] : C extends Wrapped<infer T> ? T : C extends ObjectConstructor ? Object : C extends Constructor<infer T> ? TypeFromConstructor<T> : never;
+type TransformValueDefinition<T extends ValueTypeDefinition> = T extends {
+    type: infer U;
+} ? TypeFromConstructor<U> : TypeFromConstructor<T>;
+type ValuesProperties<Values extends ValueDefinitionMap> = {
+    [K in keyof Values as `${CamelCase<K & string>}Value`]: TransformValueDefinition<Values[K]>;
+} & {
+    readonly [K in keyof Values as `has${Capitalize<CamelCase<K & string>>}Value`]: boolean;
+};
+type TargetTypeDefinition = typeof Element | InstanceType<typeof Wrapped>;
+type TargetsDefinitionMap = {
+    [token: string]: TargetTypeDefinition;
+};
+type TransformTargetDefinition<T extends TargetTypeDefinition> = T extends Wrapped<infer U> ? U : T extends new (...args: any[]) => infer R ? R : never;
+type TargetsProperties<Targets extends TargetsDefinitionMap> = {
+    readonly [K in keyof Targets as `${CamelCase<K & string>}Target`]: TransformTargetDefinition<Targets[K]>;
+} & {
+    readonly [K in keyof Targets as `has${Capitalize<CamelCase<K & string>>}Target`]: boolean;
+} & {
+    readonly [K in keyof Targets as `${CamelCase<K & string>}Targets`]: TransformTargetDefinition<Targets[K]>[];
+};
+type OutletsDefinitionMap = {
+    [token: string]: Constructor<Controller>;
+};
+type OutletProperties<Outlets extends OutletsDefinitionMap> = {
+    readonly [K in keyof Outlets as `${CamelCase<K & string>}Outlet`]: InstanceType<Outlets[K]>;
+} & {
+    readonly [K in keyof Outlets as `has${Capitalize<CamelCase<K & string>>}Outlet`]: boolean;
+} & {
+    readonly [K in keyof Outlets as `${CamelCase<K & string>}Outlets`]: InstanceType<Outlets[K]>[];
+};
+type Configuration<Values extends ValueDefinitionMap, Targets extends TargetsDefinitionMap, Classes extends readonly string[], Outlets extends OutletsDefinitionMap> = {
+    values?: Values;
+    targets?: Targets;
+    classes?: Classes;
+    outlets?: Outlets;
+};
+export declare function Typed<Base extends Constructor<Controller>, Values extends ValueDefinitionMap = {}, Targets extends TargetsDefinitionMap = {}, Classes extends readonly string[] = [], Outlets extends OutletsDefinitionMap = {}>(Base: Base, configuration?: Configuration<Values, Targets, Classes, Outlets>): typeof Base & {
+    new (...args: any[]): InstanceType<Base> & ValuesProperties<Values> & TargetsProperties<Targets> & ClassProperties<Classes> & OutletProperties<Outlets>;
+};
+export {};

package/dist/typed.js

@@ -0,0 +1,60 @@
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+class Wrapped {
+    constructor(context) {
+        this.context = context;
+        this._ = undefined;
+    }
+}
+export const TypedObject = () => new Wrapped('typed-object');
+export const TypedArray = () => new Wrapped('typed-array');
+export const Target = () => new Wrapped('target');
+function patchValueTypeDefinitionMap(values) {
+    const patchedValues = {};
+    const patchType = (type) => {
+        if (type instanceof Wrapped && type.context === 'typed-object') {
+            return Object;
+        }
+        if (type instanceof Wrapped && type.context === 'typed-array') {
+            return Array;
+        }
+        return type;
+    };
+    Object.getOwnPropertyNames(values).forEach(key => {
+        const definition = values[key];
+        if (typeof definition === 'object' && 'default' in definition && 'type' in definition) {
+            patchedValues[key] = {
+                type: patchType(definition.type),
+                default: definition.default,
+            };
+        }
+        else if (typeof definition === 'object' && 'type' in definition) {
+            patchedValues[key] = patchType(definition.type);
+        }
+        else if (definition instanceof Wrapped) {
+            patchedValues[key] = patchType(definition);
+        }
+        else {
+            patchedValues[key] = definition;
+        }
+    });
+    return patchedValues;
+}
+export function Typed(Base, configuration) {
+    var _a;
+    const { values, targets, classes, outlets } = configuration !== null && configuration !== void 0 ? configuration : {};
+    const derived = (_a = class extends Base {
+            constructor(...args) {
+                super(...args);
+            }
+        },
+        __setFunctionName(_a, "derived"),
+        _a.values = patchValueTypeDefinitionMap(values !== null && values !== void 0 ? values : {}),
+        _a.targets = Object.getOwnPropertyNames(targets !== null && targets !== void 0 ? targets : {}),
+        _a.classes = classes !== null && classes !== void 0 ? classes : [],
+        _a.outlets = Object.getOwnPropertyNames(outlets !== null && outlets !== void 0 ? outlets : {}),
+        _a);
+    return derived;
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+import { ActionEvent, Application, Controller } from "@hotwired/stimulus";
+export declare const camelCase: (value: string) => string;
+export declare const capitalize: (value: string) => string;
+export declare const isActionEvent: (value: any) => value is ActionEvent;
+export declare const getController: <T extends Controller>(app: Application, element: HTMLElement, identifier: string) => T | null;
+export declare const getControllerAsync: <T extends Controller>(app: Application, element: HTMLElement, identifier: string, timeout?: number, poll?: number) => Promise<T | null>;

package/dist/utils.js

@@ -0,0 +1,38 @@
+export const camelCase = (value) => {
+    return value
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^[A-Z]/, c => c.toLowerCase());
+};
+export const capitalize = (value) => {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+};
+export const isActionEvent = (value) => {
+    return value instanceof Event && 'params' in value && typeof value.params !== 'object';
+};
+export const getController = (app, element, identifier) => {
+    return app.getControllerForElementAndIdentifier(element, identifier);
+};
+export const getControllerAsync = async (app, element, identifier, timeout = 5000, poll = 50) => {
+    const startTime = Date.now();
+    const maxAttempts = 10;
+    let attempts = 0;
+    return new Promise((resolve) => {
+        const checkController = () => {
+            attempts++;
+            const controller = app.getControllerForElementAndIdentifier(element, identifier);
+            if (controller !== null) {
+                resolve(controller);
+            }
+            else if (Date.now() - startTime >= timeout) {
+                resolve(null);
+            }
+            else if (attempts <= maxAttempts) {
+                setTimeout(checkController);
+            }
+            else {
+                setTimeout(checkController, poll);
+            }
+        };
+        checkController();
+    });
+};