@elmethis/vue 0.4.1 → 0.5.0

package/lib-types/components/containments/elm-collapse.d.ts

@@ -0,0 +1,38 @@
+import { type CSSProperties, type HTMLAttributes } from "vue";
+export interface ElmCollapseProps extends HTMLAttributes {
+    isOpen?: boolean;
+    direction?: "row" | "column" | "both";
+    transitionTimingFunction?: CSSProperties["transitionTimingFunction"];
+}
+export declare const ElmCollapse: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    direction: {
+        type: () => "row" | "column" | "both";
+        default: string;
+    };
+    transitionTimingFunction: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    direction: {
+        type: () => "row" | "column" | "both";
+        default: string;
+    };
+    transitionTimingFunction: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    isOpen: boolean;
+    direction: "row" | "column" | "both";
+    transitionTimingFunction: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-collapse.d.ts.map

package/lib-types/components/containments/elm-collapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-collapse.d.ts","sourceRoot":"","sources":["../../../src/components/containments/elm-collapse.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAK/E,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,SAAS,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAEtC,wBAAwB,CAAC,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAAC;CACtE;AAED,eAAO,MAAM,WAAW;;;;;;cAKF,MAAM,KAAK,GAAG,QAAQ,GAAG,MAAM;;;;;;;;;;;;;cAA/B,MAAM,KAAK,GAAG,QAAQ,GAAG,MAAM;;;;;;;;;;;4EA6BnD,CAAC"}

package/lib-types/components/containments/elm-modal.d.ts

@@ -0,0 +1,43 @@
+import { type DialogHTMLAttributes, type PropType } from "vue";
+export interface ElmModalProps extends Omit<DialogHTMLAttributes, "onClose"> {
+    isOpen?: boolean;
+    /**
+     * Delay in **milliseconds** of the open/close fade. Emitted as the
+     * `--elmethis-scoped-modal-delay` custom property so the stylesheet
+     * transition stays in sync with the JS close timer. Defaults to `200`.
+     */
+    delay?: number;
+    onClose?: (event: Event, element: HTMLDialogElement) => void;
+}
+export declare const ElmModal: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: PropType<(event: Event, element: HTMLDialogElement) => void>;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: PropType<(event: Event, element: HTMLDialogElement) => void>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    isOpen: boolean;
+    onClose: (event: Event, element: HTMLDialogElement) => void;
+    delay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-modal.d.ts.map

package/lib-types/components/containments/elm-modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-modal.d.ts","sourceRoot":"","sources":["../../../src/components/containments/elm-modal.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EAEd,MAAM,KAAK,CAAC;AAUb,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC;IAC1E,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC9D;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;cAOG,QAAQ,CACxB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iBAAiB,KAAK,IAAI,CACnD;;;;;;;;;;;;;cAFiB,QAAQ,CACxB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iBAAiB,KAAK,IAAI,CACnD;;;;;qBADS,KAAK,WAAW,iBAAiB,KAAK,IAAI;;4EAoFxD,CAAC"}

package/lib-types/components/containments/elm-parallax.d.ts

@@ -0,0 +1,16 @@
+import { type HTMLAttributes, type PropType } from "vue";
+export interface ElmParallaxProps extends HTMLAttributes {
+    images: string[];
+}
+export declare const ElmParallax: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    images: {
+        type: PropType<string[]>;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    images: {
+        type: PropType<string[]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-parallax.d.ts.map

package/lib-types/components/containments/elm-parallax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-parallax.d.ts","sourceRoot":"","sources":["../../../src/components/containments/elm-parallax.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EACnB,KAAK,QAAQ,EACd,MAAM,KAAK,CAAC;AAIb,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,eAAO,MAAM,WAAW;;cAGK,QAAQ,CAAC,MAAM,EAAE,CAAC;;;;;cAAlB,QAAQ,CAAC,MAAM,EAAE,CAAC;;;iGAiC7C,CAAC"}

package/lib-types/components/containments/elm-tabs.d.ts

@@ -0,0 +1,79 @@
+import { type CSSProperties, type HTMLAttributes } from "vue";
+export interface ElmTabsProps extends HTMLAttributes {
+    /**
+     * Controlled selected tab value. Bind with `v-model:value`; when provided the
+     * parent owns the value (prop `value` + `update:value` event).
+     */
+    value?: string;
+    /**
+     * Initial selected tab value when uncontrolled.
+     */
+    defaultValue?: string;
+    transitionTimingFunction?: CSSProperties["transitionTimingFunction"];
+}
+export declare const ElmTabs: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    transitionTimingFunction: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    transitionTimingFunction: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    transitionTimingFunction: string;
+    defaultValue: string;
+    value: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export type ElmTabListProps = HTMLAttributes;
+export declare const ElmTabList: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export interface ElmTabProps extends HTMLAttributes {
+    /** Identifier matching the corresponding ElmTabPanel `value`. */
+    value: string;
+}
+export declare const ElmTab: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export interface ElmTabPanelProps extends HTMLAttributes {
+    /** Identifier matching the corresponding ElmTab `value`. */
+    value: string;
+}
+export declare const ElmTabPanel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-tabs.d.ts.map

package/lib-types/components/containments/elm-tabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-tabs.d.ts","sourceRoot":"","sources":["../../../src/components/containments/elm-tabs.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAYb,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,wBAAwB,CAAC,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAAC;CACtE;AAED,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAmClB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC;AAE7C,eAAO,MAAM,UAAU,wTAOrB,CAAC;AAEH,MAAM,WAAW,WAAY,SAAQ,cAAc;IACjD,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,MAAM;;;;;;;;;;iGAoBjB,CAAC;AAEH,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,WAAW;;;;;;;;;;iGAmBtB,CAAC"}

package/lib-types/components/containments/elm-toggle.d.ts

@@ -0,0 +1,57 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmToggleProps extends Omit<HTMLAttributes, "onToggle"> {
+    /**
+     * The summary text of the toggle. A `string` is wrapped in `ElmInlineText`;
+     * otherwise the `summary` slot is rendered.
+     */
+    summary?: string;
+    /** Initial open state for uncontrolled usage. */
+    defaultIsOpen?: boolean;
+    /** Controlled open state. Bind with `v-model:is-open`; when provided the
+     * parent owns the value (prop `isOpen` + `update:isOpen` event). */
+    isOpen?: boolean;
+    monochrome?: boolean;
+}
+export declare const ElmToggle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    summary: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultIsOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    monochrome: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:isOpen"[], "update:isOpen", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    summary: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultIsOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    monochrome: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:isOpen"?: ((...args: any[]) => any) | undefined;
+}>, {
+    isOpen: boolean;
+    summary: string;
+    defaultIsOpen: boolean;
+    monochrome: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-toggle.d.ts.map

package/lib-types/components/containments/elm-toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-toggle.d.ts","sourceRoot":"","sources":["../../../src/components/containments/elm-toggle.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAS3D,MAAM,WAAW,cAAe,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC;IACtE;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,iDAAiD;IACjD,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;wEACoE;IACpE,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAyEpB,CAAC"}

package/lib-types/components/containments/elm-tooltip.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmTooltipProps = HTMLAttributes;
+export declare const ElmTooltip: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-tooltip.d.ts.map

package/lib-types/components/containments/elm-tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-tooltip.d.ts","sourceRoot":"","sources":["../../../src/components/containments/elm-tooltip.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;AAKb,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC;AAE7C,eAAO,MAAM,UAAU,wTAkErB,CAAC"}

package/lib-types/components/containments/tabs-context.d.ts

@@ -0,0 +1,17 @@
+import type { CSSProperties, InjectionKey, Ref } from "vue";
+/**
+ * Shared state for the `ElmTabs` compound: the selected tab value, a setter,
+ * and the collapse transition timing. `ElmTab` / `ElmTabPanel` `inject` this;
+ * `ElmTabs` provides it. Replaces react's `createContext`.
+ *
+ * `selectedValue` is provided as a `Ref` (the controllable signal from
+ * `ElmTabs`) so children re-render reactively when the active tab changes.
+ */
+export interface ElmTabsContextValue {
+    selectedValue: Readonly<Ref<string>>;
+    setSelectedValue: (value: string) => void;
+    transitionTimingFunction: CSSProperties["transitionTimingFunction"];
+}
+export declare const ElmTabsContext: InjectionKey<ElmTabsContextValue>;
+export declare const useElmTabsContext: (inject: ElmTabsContextValue | undefined) => ElmTabsContextValue;
+//# sourceMappingURL=tabs-context.d.ts.map

package/lib-types/components/containments/tabs-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs-context.d.ts","sourceRoot":"","sources":["../../../src/components/containments/tabs-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE5D;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACrC,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,wBAAwB,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAAC;CACrE;AAED,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,mBAAmB,CACzC,CAAC;AAErB,eAAO,MAAM,iBAAiB,GAAI,QAAQ,mBAAmB,GAAG,SAAS,wBAKxE,CAAC"}

package/lib-types/components/fallback/elm-block-fallback.d.ts

@@ -0,0 +1,18 @@
+import { type CSSProperties, type HTMLAttributes } from "vue";
+export interface ElmBlockFallbackProps extends HTMLAttributes {
+    height?: CSSProperties["height"];
+}
+export declare const ElmBlockFallback: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    height: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-block-fallback.d.ts.map

package/lib-types/components/fallback/elm-block-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-block-fallback.d.ts","sourceRoot":"","sources":["../../../src/components/fallback/elm-block-fallback.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAO/E,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D,MAAM,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;CAClC;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;4EAmB3B,CAAC"}

package/lib-types/components/fallback/elm-rectangle-wave.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmRectangleWaveProps = HTMLAttributes;
+export declare const ElmRectangleWave: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-rectangle-wave.d.ts.map

package/lib-types/components/fallback/elm-rectangle-wave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-rectangle-wave.d.ts","sourceRoot":"","sources":["../../../src/components/fallback/elm-rectangle-wave.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAK3D,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC;AAEnD,eAAO,MAAM,gBAAgB,wTAQ3B,CAAC"}

package/lib-types/components/fallback/elm-unsupported-block.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmUnsupportedBlockProps extends HTMLAttributes {
+    details?: string;
+}
+export declare const ElmUnsupportedBlock: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    details: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    details: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    details: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-unsupported-block.d.ts.map

package/lib-types/components/fallback/elm-unsupported-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-unsupported-block.d.ts","sourceRoot":"","sources":["../../../src/components/fallback/elm-unsupported-block.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAM3D,MAAM,WAAW,wBAAyB,SAAQ,cAAc;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;4EAsC9B,CAAC"}

package/lib-types/components/form/elm-button.d.ts

@@ -0,0 +1,70 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmButtonProps extends HTMLAttributes {
+    /**
+     * Whether the button is in loading state.
+     */
+    isLoading?: boolean;
+    /**
+     * Whether the button is block.
+     */
+    block?: boolean;
+    color?: string;
+    /**
+     * Whether the button is primary.
+     */
+    primary?: boolean;
+    /**
+     * Whether the button is disabled.
+     */
+    disabled?: boolean;
+}
+export declare const ElmButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    primary: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    primary: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    block: boolean;
+    disabled: boolean;
+    primary: boolean;
+    isLoading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-button.d.ts.map

package/lib-types/components/form/elm-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-button.d.ts","sourceRoot":"","sources":["../../../src/components/form/elm-button.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,KAAK,CAAC;AAMb,MAAM,WAAW,cAAe,SAAQ,cAAc;IACpD;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA2EpB,CAAC"}

package/lib-types/components/form/elm-checkbox.d.ts

@@ -0,0 +1,75 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmCheckboxProps extends Omit<HTMLAttributes, "onClick"> {
+    /**
+     * The label displayed.
+     */
+    label: string;
+    /**
+     * Whether the checkbox is in a loading state.
+     */
+    isLoading?: boolean;
+    /**
+     * Whether the checkbox is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Controlled checked state. Bind with `v-model:checked`; when provided the
+     * parent owns the value (prop `checked` + `update:checked` event).
+     */
+    checked?: boolean;
+    /**
+     * Initial checked state when uncontrolled.
+     */
+    defaultChecked?: boolean;
+}
+export declare const ElmCheckbox: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checked: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultChecked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:checked"[], "update:checked", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checked: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    defaultChecked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    isLoading: boolean;
+    checked: boolean;
+    defaultChecked: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-checkbox.d.ts.map

package/lib-types/components/form/elm-checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-checkbox.d.ts","sourceRoot":"","sources":["../../../src/components/form/elm-checkbox.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAO3D,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC;IACvE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAwLtB,CAAC"}

package/lib-types/components/form/elm-select.d.ts

@@ -0,0 +1,108 @@
+import { type HTMLAttributes, type PropType } from "vue";
+export interface ElmSelectOption {
+    id: string;
+    label: string;
+    /**
+     * Optional icon URL displayed alongside the option label.
+     */
+    icon?: string;
+}
+export interface ElmSelectProps extends Omit<HTMLAttributes, "onChange"> {
+    /**
+     * Label for the select component.
+     */
+    label: string;
+    /**
+     * Placeholder text shown when no option is selected.
+     */
+    placeholder?: string;
+    /**
+     * Whether the select is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the select is in a loading state.
+     */
+    isLoading?: boolean;
+    /**
+     * Options to display in the dropdown.
+     */
+    options: ElmSelectOption[];
+    /**
+     * Currently selected option id. Bind with `v-model:selected-option-id`
+     * (prop `selectedOptionId` + `update:selectedOptionId` event).
+     */
+    selectedOptionId?: string | null;
+    /**
+     * Initial selected option id for the uncontrolled case.
+     */
+    defaultSelectedOptionId?: string | null;
+}
+export declare const ElmSelect: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: PropType<ElmSelectOption[]>;
+        required: true;
+    };
+    selectedOptionId: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultSelectedOptionId: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:selectedOptionId"[], "update:selectedOptionId", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: PropType<ElmSelectOption[]>;
+        required: true;
+    };
+    selectedOptionId: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultSelectedOptionId: {
+        type: PropType<string | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    "onUpdate:selectedOptionId"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    isLoading: boolean;
+    selectedOptionId: string | null;
+    defaultSelectedOptionId: string | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-select.d.ts.map

package/lib-types/components/form/elm-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-select.d.ts","sourceRoot":"","sources":["../../../src/components/form/elm-select.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,QAAQ,EACd,MAAM,KAAK,CAAC;AAiBb,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAe,SAAQ,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC;IACtE;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,eAAe,EAAE,CAAC;IAE3B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEjC;;OAEG;IACH,uBAAuB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;cAOQ,QAAQ,CAAC,eAAe,EAAE,CAAC;;;;cAEnC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC;;;;cAIvB,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;cANf,QAAQ,CAAC,eAAe,EAAE,CAAC;;;;cAEnC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC;;;;cAIvB,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC;;;;;;;;;;;4EAwG3C,CAAC"}