@elmethis/vue 0.4.2 → 0.5.0

package/lib-types/components/others/elm-markdown.d.ts

@@ -0,0 +1,31 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmMarkdownProps extends HTMLAttributes {
+    markdown: string;
+    /**
+     * Set to true when markdown is being streamed incrementally.
+     * Keeps completed blocks stable and only re-renders the trailing block on each token.
+     */
+    isStreaming?: boolean;
+}
+export declare const ElmMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        required: true;
+    };
+    isStreaming: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        required: true;
+    };
+    isStreaming: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    isStreaming: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-markdown.d.ts.map

package/lib-types/components/others/elm-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-markdown.d.ts","sourceRoot":"","sources":["../../../src/components/others/elm-markdown.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAGpB,MAAM,KAAK,CAAC;AAmBb,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAqND,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;4EAyCtB,CAAC"}

package/lib-types/components/others/use-wordle.d.ts

@@ -0,0 +1,26 @@
+import { type Component, type ComputedRef } from "vue";
+export type LetterStatus = "correct" | "present" | "absent";
+export type GameStatus = "playing" | "won" | "lost";
+export interface LetterResult {
+    letter: string;
+    status: LetterStatus;
+}
+export interface UseWordleOptions {
+    /** Override the target word (useful for testing). Must be a lowercase 5-letter word. */
+    initialWord?: string;
+}
+export interface UseWordleReturn {
+    answer: ComputedRef<string>;
+    board: ComputedRef<LetterResult[][]>;
+    currentGuess: ComputedRef<string>;
+    gameStatus: ComputedRef<GameStatus>;
+    letterStatuses: ComputedRef<Record<string, LetterStatus>>;
+    errorMessage: ComputedRef<string>;
+    submit: () => void;
+    addLetter: (letter: string) => void;
+    removeLetter: () => void;
+    reset: () => void;
+    Wordle: Component;
+}
+export declare const useWordle: (options?: UseWordleOptions) => UseWordleReturn;
+//# sourceMappingURL=use-wordle.d.ts.map

package/lib-types/components/others/use-wordle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-wordle.d.ts","sourceRoot":"","sources":["../../../src/components/others/use-wordle.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,SAAS,EACd,KAAK,WAAW,EACjB,MAAM,KAAK,CAAC;AAoBb,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,wFAAwF;IACxF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAoKD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,KAAK,EAAE,WAAW,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACrC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,UAAU,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IACpC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;IAC1D,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,MAAM,EAAE,SAAS,CAAC;CACnB;AAKD,eAAO,MAAM,SAAS,GAAI,UAAU,gBAAgB,KAAG,eAgMtD,CAAC"}

package/lib-types/components/others/wordle/validGuesses.d.ts

@@ -0,0 +1,2 @@
+export declare const VALIDGUESSES: string[];
+//# sourceMappingURL=validGuesses.d.ts.map

package/lib-types/components/others/wordle/validGuesses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validGuesses.d.ts","sourceRoot":"","sources":["../../../../src/components/others/wordle/validGuesses.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,UAk6UxB,CAAC"}

package/lib-types/components/others/wordle/wordlist.d.ts

@@ -0,0 +1,2 @@
+export declare const WORDS: string[];
+//# sourceMappingURL=wordlist.d.ts.map

package/lib-types/components/others/wordle/wordlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wordlist.d.ts","sourceRoot":"","sources":["../../../../src/components/others/wordle/wordlist.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,UA8nLjB,CAAC"}

package/lib-types/components/table/elm-table-body.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmTableBodyProps = HTMLAttributes;
+export declare const ElmTableBody: 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-table-body.d.ts.map

package/lib-types/components/table/elm-table-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-table-body.d.ts","sourceRoot":"","sources":["../../../src/components/table/elm-table-body.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAIpE,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C,eAAO,MAAM,YAAY,wTAMvB,CAAC"}

package/lib-types/components/table/elm-table-cell.d.ts

@@ -0,0 +1,58 @@
+import { type PropType, type TdHTMLAttributes } from "vue";
+export interface ElmTableCellProps extends TdHTMLAttributes {
+    /**
+     * Force this cell to render as a `<th>`. Use for cells that are headers but
+     * live outside `<ElmTableHeader>` (e.g. a mid-table grouping row). Cells
+     * inside `<ElmTableHeader>` are promoted automatically.
+     */
+    isHeader?: boolean;
+    /**
+     * 0-based column index within the row. When the surrounding `<ElmTable>` has
+     * `hasRowHeader`, the cell at `columnIndex === 0` is promoted to
+     * `<th scope="row">` for accessibility.
+     */
+    columnIndex?: number;
+    /** Convenience for plain-text cells. Equivalent to passing children. */
+    text?: string;
+}
+export declare const ElmTableCell: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    isHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    columnIndex: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    text: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    scope: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    columnIndex: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    text: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    scope: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    text: string;
+    isHeader: boolean;
+    columnIndex: number;
+    scope: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-table-cell.d.ts.map

package/lib-types/components/table/elm-table-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-table-cell.d.ts","sourceRoot":"","sources":["../../../src/components/table/elm-table-cell.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAEb,KAAK,gBAAgB,EACtB,MAAM,KAAK,CAAC;AAMb,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACzD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;cAOI,QAAQ,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;cAAhB,QAAQ,CAAC,MAAM,CAAC;;;;;;;;4EAsD3C,CAAC"}

package/lib-types/components/table/elm-table-header.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmTableHeaderProps = HTMLAttributes;
+export declare const ElmTableHeader: 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-table-header.d.ts.map

package/lib-types/components/table/elm-table-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-table-header.d.ts","sourceRoot":"","sources":["../../../src/components/table/elm-table-header.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAMpE,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC;AAEjD,eAAO,MAAM,cAAc,wTAWzB,CAAC"}

package/lib-types/components/table/elm-table-row.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmTableRowProps = HTMLAttributes;
+export declare const ElmTableRow: 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-table-row.d.ts.map

package/lib-types/components/table/elm-table-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-table-row.d.ts","sourceRoot":"","sources":["../../../src/components/table/elm-table-row.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAK3D,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAE9C,eAAO,MAAM,WAAW,wTAQtB,CAAC"}

package/lib-types/components/table/elm-table.d.ts

@@ -0,0 +1,28 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmTableProps extends HTMLAttributes {
+    caption?: string;
+    hasRowHeader?: boolean;
+}
+export declare const ElmTable: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    caption: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    hasRowHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    caption: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    hasRowHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    caption: string;
+    hasRowHeader: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-table.d.ts.map

package/lib-types/components/table/elm-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-table.d.ts","sourceRoot":"","sources":["../../../src/components/table/elm-table.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAQ9E,MAAM,WAAW,aAAc,SAAQ,cAAc;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;4EAiCnB,CAAC"}

package/lib-types/components/table/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./elm-table";
+export * from "./elm-table-body";
+export * from "./elm-table-cell";
+export * from "./elm-table-header";
+export * from "./elm-table-row";
+export * from "./table-context";
+//# sourceMappingURL=index.d.ts.map

package/lib-types/components/table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/table/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC"}

package/lib-types/components/table/table-context.d.ts

@@ -0,0 +1,22 @@
+import type { InjectionKey, Ref } from "vue";
+/**
+ * Exposes whether the surrounding `<ElmTable>` was rendered with
+ * `hasRowHeader`. Cells read this to decide whether to self-promote the first
+ * column to `<th scope="row">`.
+ *
+ * Provided as a `Ref<boolean>` (a `computed` from `ElmTable`) so reactivity is
+ * wired through; cells `inject` with a `ref(false)` default for cells rendered
+ * outside an `<ElmTable>` ancestor (e.g. in isolated tests).
+ */
+export declare const HasRowHeaderContext: InjectionKey<Readonly<Ref<boolean>>>;
+/**
+ * Which section of the table a row/cell lives in. `ElmTableHeader` and
+ * `ElmTableBody` provide this so `ElmTableCell` can render `<th>` vs `<td>`
+ * without each cell needing an explicit prop.
+ *
+ * `"foot"` is reserved for a future `<ElmTableFoot>`. Cells `inject` with a
+ * `"body"` default to match cells used outside a section.
+ */
+export type TableSection = "head" | "body" | "foot";
+export declare const TableSectionContext: InjectionKey<TableSection>;
+//# sourceMappingURL=table-context.d.ts.map

package/lib-types/components/table/table-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-context.d.ts","sourceRoot":"","sources":["../../../src/components/table/table-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE7C;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAEpE,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AACpD,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,YAAY,CAC9B,CAAC"}

package/lib-types/components/typography/elm-block-quote.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmBlockQuoteProps = HTMLAttributes;
+export declare const ElmBlockQuote: 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-block-quote.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elm-block-quote.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-block-quote.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAQ3D,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAEhD,eAAO,MAAM,aAAa,wTAkBxB,CAAC"}

package/lib-types/components/typography/elm-callout.d.ts

@@ -0,0 +1,22 @@
+import { type HTMLAttributes, type PropType } from "vue";
+export type AlertType = "note" | "tip" | "important" | "warning" | "caution";
+export interface ElmCalloutProps extends HTMLAttributes {
+    /**
+     * Type of alert
+     */
+    type?: AlertType;
+}
+export declare const ElmCallout: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    type: {
+        type: PropType<AlertType>;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: PropType<AlertType>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    type: AlertType;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-callout.d.ts.map

package/lib-types/components/typography/elm-callout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-callout.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-callout.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAC;AAa1E,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;AAU7E,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD;;OAEG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,eAAO,MAAM,UAAU;;cAGK,QAAQ,CAAC,SAAS,CAAC;;;;;cAAnB,QAAQ,CAAC,SAAS,CAAC;;;;;4EAmB7C,CAAC"}

package/lib-types/components/typography/elm-divider.d.ts

@@ -0,0 +1,4 @@
+import { type HTMLAttributes } from "vue";
+export type ElmDividerProps = HTMLAttributes;
+export declare const ElmDivider: 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-divider.d.ts.map

package/lib-types/components/typography/elm-divider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-divider.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-divider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAK3D,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC;AAE7C,eAAO,MAAM,UAAU,wTAgBrB,CAAC"}

package/lib-types/components/typography/elm-fragment-identifier.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmFragmentIdentifierProps extends HTMLAttributes {
+    /**
+     * ID of the heading element.
+     */
+    id: string;
+}
+export declare const ElmFragmentIdentifier: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-fragment-identifier.d.ts.map

package/lib-types/components/typography/elm-fragment-identifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-fragment-identifier.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-fragment-identifier.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAK3D,MAAM,WAAW,0BAA2B,SAAQ,cAAc;IAChE;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;iGAqChC,CAAC"}

package/lib-types/components/typography/elm-heading.d.ts

@@ -0,0 +1,38 @@
+import { type HTMLAttributes } from "vue";
+export interface ElmHeadingProps extends HTMLAttributes {
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    text?: string;
+    /** Anchor id; when present a fragment-identifier link is rendered. */
+    id?: string;
+}
+export declare const ElmHeading: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    level: {
+        type: () => 1 | 2 | 3 | 4 | 5 | 6;
+        required: true;
+    };
+    text: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    level: {
+        type: () => 1 | 2 | 3 | 4 | 5 | 6;
+        required: true;
+    };
+    text: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    text: string;
+    id: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-heading.d.ts.map

package/lib-types/components/typography/elm-heading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-heading.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-heading.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAO/E,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAE7B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,sEAAsE;IACtE,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAWD,eAAO,MAAM,UAAU;;cAGM,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC;;;;;;;;;;;;;cAA3B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC;;;;;;;;;;;;;;4EAwCtD,CAAC"}

package/lib-types/components/typography/elm-inline-text.d.ts

@@ -0,0 +1,172 @@
+import { type CSSProperties, type HTMLAttributes } from "vue";
+export interface ElmInlineTextProps extends HTMLAttributes {
+    /**
+     * Specifies the color of the text.
+     *
+     * Accepts any CSS color value, including theme tokens via `var(...)`.
+     * Defaults to `var(--elmethis-color-neutral)` when omitted.
+     *
+     * e.g.) `'red'`, `'#ff0000'`, `'rgba(255, 0, 0, 0.5)'`,
+     * `'var(--elmethis-color-primary)'`
+     */
+    color?: CSSProperties["color"];
+    /**
+     * Specifies the font size of the text.
+     */
+    size?: CSSProperties["fontSize"];
+    /**
+     * Specifies whether the text should be bold.
+     */
+    bold?: boolean;
+    /**
+     * Specifies whether the text should be italic.
+     */
+    italic?: boolean;
+    /**
+     * Specifies whether the text should be underlined.
+     */
+    underline?: boolean;
+    /**
+     * Specifies whether the text should be strikethrough.
+     */
+    strikethrough?: boolean;
+    /**
+     * Specifies whether the text should be displayed as code.
+     */
+    code?: boolean;
+    /**
+     * Specifies whether the text should be displayed as a keyboard key.
+     */
+    kbd?: boolean;
+    /**
+     * Specifies the background color of the text.
+     */
+    backgroundColor?: CSSProperties["backgroundColor"];
+    /**
+     * The ruby text to display.
+     */
+    ruby?: string;
+    /**
+     * The URL to navigate to.
+     *
+     * e.g. `https://example.com`
+     */
+    href?: string;
+    /**
+     * Optional favicon URL displayed alongside the link.
+     */
+    favicon?: string;
+}
+export declare const ElmInlineText: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    bold: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    italic: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    underline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strikethrough: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    code: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    kbd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ruby: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    favicon: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    bold: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    italic: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    underline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strikethrough: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    code: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    kbd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ruby: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    favicon: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    code: boolean;
+    kbd: boolean;
+    ruby: string;
+    bold: boolean;
+    size: string;
+    color: string;
+    backgroundColor: string;
+    italic: boolean;
+    underline: boolean;
+    strikethrough: boolean;
+    href: string;
+    favicon: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-inline-text.d.ts.map

package/lib-types/components/typography/elm-inline-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-inline-text.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-inline-text.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EAGpB,MAAM,KAAK,CAAC;AAQb,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAE/B;;OAEG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAEjC;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IAEd;;OAEG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAEnD;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA2FxB,CAAC"}

package/lib-types/components/typography/elm-list.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes, type PropType } from "vue";
+export interface ElmListProps extends Omit<HTMLAttributes, "type"> {
+    listStyle?: "unordered" | "ordered";
+    type?: "a" | "i" | "1" | "A" | "I";
+}
+export declare const ElmList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    listStyle: {
+        type: PropType<"unordered" | "ordered">;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    listStyle: {
+        type: PropType<"unordered" | "ordered">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    listStyle: "ordered" | "unordered";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=elm-list.d.ts.map

package/lib-types/components/typography/elm-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-list.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-list.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAC;AAM1E,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC;IAChE,SAAS,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACpC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CACpC;AAED,eAAO,MAAM,OAAO;;cAIE,QAAQ,CAAC,WAAW,GAAG,SAAS,CAAC;;;;;cAAjC,QAAQ,CAAC,WAAW,GAAG,SAAS,CAAC;;;;;4EAyBrD,CAAC"}

package/lib-types/components/typography/elm-paragraph.d.ts

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

package/lib-types/components/typography/elm-paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-paragraph.d.ts","sourceRoot":"","sources":["../../../src/components/typography/elm-paragraph.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAmB,MAAM,KAAK,CAAC;AAM5E,MAAM,WAAW,iBAAkB,SAAQ,cAAc;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;4EAsCvB,CAAC"}

package/lib-types/hooks/use-bindable-signal.d.ts

@@ -0,0 +1,44 @@
+import type { Ref, UnwrapRef } from "vue";
+/**
+ * Optionally-bindable single-value state — the Vue port of qwik's
+ * `useBindableSignal` / react's `useControllableState` wrapper.
+ *
+ * Built on Vue's `v-model` contract: a model prop (`key`) plus its
+ * `update:<key>` event. `defineModel` would generate the same contract, but it
+ * is a `<script setup>` compiler macro and is unavailable in our
+ * `defineComponent` + TSX authoring style — so we wire the contract by hand and
+ * wrap it with `useVModel` here.
+ *
+ * - **Bound:** the parent binds `v-model:<key>` (passes the prop + listens to
+ *   `update:<key>`). The hook returns a ref that reads through to the prop and
+ *   writes by emitting, so the parent stays the source of truth.
+ * - **Unbound:** the parent omits the prop (it must default to `undefined` so
+ *   "unbound" is distinguishable from a real `false`/`""`/`0`). The hook owns
+ *   internal state seeded with `defaultValue`.
+ *
+ * Returns a writable `Ref<T>`; read/write via `.value`, mirroring qwik's
+ * `Signal<T>`. For multi-field / nested-struct state, prefer a store-shaped
+ * equivalent rather than this single-value hook.
+ *
+ * @example
+ *   // props: { checked: { type: Boolean, default: undefined }, ... }
+ *   // emits: ["update:checked"]
+ *   const isChecked = useBindableSignal({
+ *     props,
+ *     key: "checked",
+ *     emit,
+ *     defaultValue: props.defaultChecked ?? false,
+ *   });
+ *   // Read `isChecked.value`; write with `isChecked.value = next`.
+ */
+export declare function useBindableSignal<P extends object, K extends keyof P>(args: {
+    /** The component's reactive `props` object. */
+    props: P;
+    /** The model prop name (e.g. `"checked"`). Must default to `undefined`. */
+    key: K;
+    /** The component's `emit`; the hook fires `update:<key>` through it. */
+    emit: (event: `update:${string & K}`, ...payload: unknown[]) => void;
+    /** Initial value for the internal state when unbound. */
+    defaultValue: NonNullable<P[K]>;
+}): Ref<UnwrapRef<P[K]>>;
+//# sourceMappingURL=use-bindable-signal.d.ts.map