@vastare/fundatio 0.1.0

package/dist/types/elements/form/datalist/index.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Fundatio Design Foundation: Datalist element helpers.
+ *
+ * @remarks
+ * The datalist element (`<datalist>`) contains a set of `<option>` elements that
+ * represent permissible or recommended values for an associated form control
+ * (most commonly an `<input>`), connected via the input's `list` attribute.
+ *
+ * Best-practice guidance:
+ * - Pair a `<datalist>` with an `<input>` using a stable, unique `id` on the
+ *   datalist and a matching `list` attribute on the input.
+ * - Use `<datalist>` for suggestions, not strict validation. If users must pick
+ *   from a fixed set, prefer `<select>`.
+ * - Populate suggestions using descendant `<option>` elements, typically with
+ *   `value` attributes.
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create `<datalist>` elements in vanilla JS/TS without templates
+ * - apply consistent global attributes safely
+ * - use a stable "enhancement" hook if Fundatio ever needs runtime behavior
+ *
+ * This module has no side effects and does not mutate the DOM unless you call
+ * its functions.
+ *
+ * Attributes:
+ * - `<datalist>` supports global attributes only (no element-specific content
+ *   attributes).
+ *
+ * Security:
+ * - Global attribute escape hatches are guarded by Fundatio's `dom.ts` helpers which
+ *   block inline event handler attributes (e.g. `onclick`) and raw `style`
+ *   attribute injection (use the `style` object field instead).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/datalist
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by Fundatio element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs (e.g. `lable`).
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for datalist.
+ *
+ * @category Constants
+ */
+export declare const DATALIST_TAG: "datalist";
+/**
+ * A CSS selector targeting datalist elements.
+ *
+ * @category Constants
+ */
+export declare const DATALIST_SELECTOR = "datalist";
+/**
+ * Attribute bag for datalist creation/enhancement.
+ *
+ * @remarks
+ * Datalist elements accept standard HTML global attributes.
+ *
+ * Fundatio also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.
+ *
+ * @category Attributes
+ */
+export type DatalistAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+};
+/**
+ * Create a datalist element with optional text content and global attributes.
+ *
+ * @remarks
+ * While `<datalist>` is typically populated with `<option>` children, this helper
+ * follows Fundatio's consistent "optional text" factory signature for non-void elements.
+ *
+ * - Text content is assigned via `textContent` (never `innerHTML`).
+ * - Global attributes are applied via Fundatio's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * @param text - Optional text content for the datalist (rare, but supported).
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<datalist>` element.
+ *
+ * @example
+ * ```ts
+ * import { createDatalist } from "@Vastare/Fundatio/elements/form/datalist";
+ *
+ * const dl = createDatalist(undefined, { id: "city-list" });
+ * document.body.appendChild(dl);
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createDatalist(text?: string, attrs?: DatalistAttrs): ElementOf<typeof DATALIST_TAG>;
+/**
+ * Enhance datalist elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `1.0.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhanceDatalists(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/form/datalist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/form/datalist/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAElF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAG,UAAmB,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IACtD;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AA6BF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAC5B,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,aAAa,GACpB,SAAS,CAAC,OAAO,YAAY,CAAC,CAEhC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAGlE"}

package/dist/types/elements/form/fieldset/index.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Fundatio Design Foundation: Fieldset element helpers.
+ *
+ * @remarks
+ * The fieldset element (`<fieldset>`) groups related form controls, typically
+ * with a `<legend>` that provides an accessible label for the group.
+ *
+ * Best-practice guidance:
+ * - Use `<fieldset>` to group related controls (e.g. radio button sets).
+ * - Prefer a meaningful `<legend>` as the first child to label the group.
+ * - Do not use `<fieldset>` purely for layout; use CSS for visual grouping.
+ *
+ * Attribute behavior notes:
+ * - When `disabled` is set on a `<fieldset>`, user agents disable descendant
+ *   form controls, except those that are descendants of the fieldset's first
+ *   `<legend>` child (if any). This is native platform behavior.
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create fieldsets in vanilla JS/TS without templates
+ * - apply consistent global attributes safely
+ * - use a stable "enhancement" hook if Fundatio ever needs runtime behavior
+ *
+ * This module has no side effects and does not mutate the DOM unless you call
+ * its functions.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/fieldset
+ * @see https://www.w3.org/WAI/tutorials/forms/grouping/
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by Fundatio element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs.
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for fieldset groups.
+ *
+ * @category Constants
+ */
+export declare const FIELDSET_TAG: "fieldset";
+/**
+ * A CSS selector targeting fieldset elements.
+ *
+ * @category Constants
+ */
+export declare const FIELDSET_SELECTOR = "fieldset";
+/**
+ * Attribute bag for fieldset creation/enhancement.
+ *
+ * @remarks
+ * Fieldset accepts standard HTML global attributes plus fieldset-specific
+ * attributes (`disabled`, `form`, `name`).
+ *
+ * Fundatio also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.
+ *
+ * @category Attributes
+ */
+export type FieldsetAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+    /**
+     * Disables descendant form controls (native platform behavior).
+     *
+     * @remarks
+     * When set, controls inside the first `<legend>` (if present) are typically
+     * excluded from disabling per spec/user agent behavior.
+     */
+    disabled?: boolean;
+    /**
+     * Associates the fieldset with a form element by ID, even if not a descendant.
+     */
+    form?: string;
+    /**
+     * Name of the fieldset (submitted/associated in form processing contexts).
+     */
+    name?: string;
+};
+/**
+ * Create a fieldset element with optional text content and attributes.
+ *
+ * @remarks
+ * - Text content is assigned via `textContent` (never `innerHTML`).
+ * - Global attributes are applied via Fundatio's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * @param text - Optional text content for the fieldset (rare; most fieldsets contain child nodes).
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<fieldset>` element.
+ *
+ * @example
+ * ```ts
+ * import { createFieldset } from "@Vastare/Fundatio/elements/form/fieldset";
+ *
+ * const fs = createFieldset(undefined, { disabled: false });
+ * // fs.appendChild(createLegend("Shipping address"));
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createFieldset(text?: string, attrs?: FieldsetAttrs): ElementOf<typeof FIELDSET_TAG>;
+/**
+ * Enhance fieldset elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `1.0.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhanceFieldsets(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/form/fieldset/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/form/fieldset/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAiC,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAElG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAG,UAAmB,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IACtD;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;IAEtB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AA+CF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,aAAa,GACpB,SAAS,CAAC,OAAO,YAAY,CAAC,CAEhC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAGlE"}

package/dist/types/elements/form/form/index.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Fundatio Design Foundation: Form element helpers.
+ *
+ * @remarks
+ * The form element (`<form>`) groups interactive controls for submitting data.
+ *
+ * Best-practice guidance:
+ * - Prefer HTTPS endpoints for `action` to protect user data in transit.
+ * - Use `method="post"` for submissions that change server state or include sensitive data.
+ * - Use `enctype="multipart/form-data"` when uploading files.
+ * - Provide explicit labels for controls and ensure accessible naming.
+ * - Consider `rel="noopener"` when using `target="_blank"` to avoid `window.opener` exposure.
+ *
+ * Fundatio notes:
+ * - This module is framework-agnostic and has no side effects.
+ * - Global attributes are applied via Fundatio's shared DOM helper, which blocks:
+ *   - inline event handler attributes (e.g. `onclick`)
+ *   - raw `style` attribute injection (use the `style` object instead)
+ * - Text passed to factories is assigned via `textContent` (never `innerHTML`).
+ *
+ * References:
+ * - MDN: `<form>` element :contentReference[oaicite:3]{index=3}
+ * - WHATWG HTML: Forms & submission attributes :contentReference[oaicite:4]{index=4}
+ * - MDN: `rel` on `<form>` / `noopener` :contentReference[oaicite:5]{index=5}
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by Fundatio element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs.
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for forms.
+ *
+ * @category Constants
+ */
+export declare const FORM_TAG: "form";
+/**
+ * A CSS selector targeting form elements.
+ *
+ * @category Constants
+ */
+export declare const FORM_SELECTOR = "form";
+/**
+ * Allowed values for the form `method` attribute.
+ *
+ * @remarks
+ * HTML supports `get`, `post`, and `dialog` (for dialog-associated forms).
+ *
+ * @category Types
+ */
+export type FormMethod = 'get' | 'post' | 'dialog';
+/**
+ * Allowed values for the form `enctype` attribute.
+ *
+ * @category Types
+ */
+export type FormEnctype = 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain';
+/**
+ * Allowed values for the form `autocomplete` attribute.
+ *
+ * @category Types
+ */
+export type FormAutocomplete = 'on' | 'off';
+/**
+ * Attribute bag for form creation/enhancement.
+ *
+ * @remarks
+ * `<form>` supports standard HTML global attributes plus submission-related
+ * attributes (action, method, enctype, target, etc.).
+ *
+ * Fundatio also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.
+ *
+ * @category Attributes
+ */
+export type FormAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * URL that processes the form submission.
+     *
+     * @remarks
+     * If omitted, the user agent submits to the current document URL.
+     */
+    action?: string;
+    /**
+     * HTTP method used to submit the form.
+     *
+     * @remarks
+     * Valid values are `get`, `post`, and `dialog`.
+     */
+    method?: FormMethod;
+    /**
+     * Encoding type for the form submission.
+     *
+     * @remarks
+     * Use `multipart/form-data` when uploading files.
+     */
+    enctype?: FormEnctype;
+    /**
+     * Character encodings that are acceptable for server processing.
+     *
+     * @remarks
+     * Maps to the `accept-charset` attribute.
+     */
+    acceptCharset?: string;
+    /**
+     * Whether the browser may autofill this form.
+     */
+    autocomplete?: FormAutocomplete;
+    /**
+     * Name of the form, used for referencing the form in scripts and documents.
+     */
+    name?: string;
+    /**
+     * Disable constraint validation when submitting the form.
+     *
+     * @remarks
+     * Maps to the boolean `novalidate` attribute (represented by attribute presence).
+     */
+    noValidate?: boolean;
+    /**
+     * Where to display the response after submitting the form.
+     *
+     * @remarks
+     * Common values: `_self`, `_blank`, `_parent`, `_top`, or a named browsing context.
+     */
+    target?: '_self' | '_blank' | '_parent' | '_top' | (string & {});
+    /**
+     * Relationship (link types) for the form submission when `target` creates a new context.
+     *
+     * @remarks
+     * This is a space-separated list of tokens (e.g. `noopener noreferrer`).
+     */
+    rel?: string;
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+};
+/**
+ * Create a form element with optional fallback text and attributes.
+ *
+ * @remarks
+ * - Fallback text is assigned via `textContent` (never `innerHTML`).
+ * - Global attributes are applied via Fundatio's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * @param text - Optional text content for the form (rare, but supported for parity).
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<form>` element.
+ *
+ * @example
+ * ```ts
+ * import { createForm } from "@Vastare/Fundatio/elements/form/form";
+ *
+ * const form = createForm(undefined, {
+ *   action: "/submit",
+ *   method: "post",
+ *   enctype: "application/x-www-form-urlencoded",
+ * });
+ * document.body.appendChild(form);
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createForm(text?: string, attrs?: FormAttrs): ElementOf<typeof FORM_TAG>;
+/**
+ * Enhance form elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `1.0.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhanceForms(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/form/form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/form/form/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAiC,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAElG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAG,MAAe,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,aAAa,SAAS,CAAC;AAEpC;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,mCAAmC,GACnC,qBAAqB,GACrB,YAAY,CAAC;AAEjB;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,KAAK,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IAClD;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IAEpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;IAEtB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAEhC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAEjE;;;;;OAKG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAwEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC,OAAO,QAAQ,CAAC,CAEvF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAG9D"}

package/dist/types/elements/form/index.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Form element factories.
+ *
+ * Provides framework-agnostic factory functions for common HTML form elements.
+ *
+ * These factories:
+ * - Create semantic form structures using Fundatio's hardened DOM helpers.
+ * - Forward curated global attributes.
+ * - Enforce structured, typed attribute bags.
+ * - Preserve correct form semantics and associations (e.g. labels, fieldsets).
+ * - Prevent unsafe attribute injection.
+ *
+ * @module elements/form
+ * @since 1.0.0
+ */
+/**
+ * `<button>` element factory namespace.
+ *
+ * Represents a clickable button used to submit forms, reset forms, or trigger
+ * custom actions.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button
+ */
+export * as button from './button';
+/**
+ * `<datalist>` element factory namespace.
+ *
+ * Represents a set of `<option>` suggestions for an associated `<input>`,
+ * enabling autocomplete-like behavior.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist
+ */
+export * as datalist from './datalist';
+/**
+ * `<fieldset>` element factory namespace.
+ *
+ * Represents a grouping container for related form controls, typically paired
+ * with a `<legend>` that labels the group.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/fieldset
+ */
+export * as fieldset from './fieldset';
+/**
+ * `<form>` element factory namespace.
+ *
+ * Represents a document section containing interactive controls for submitting
+ * information to a web server or handling via client-side logic.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form
+ */
+export * as form from './form';
+/**
+ * `<input>` element factory namespace.
+ *
+ * Represents an interactive control for entering data. The `type` attribute
+ * determines the control's behavior and UI.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input
+ */
+export * as input from './input';
+/**
+ * `<label>` element factory namespace.
+ *
+ * Represents a caption for a form control, improving usability and
+ * accessibility. Typically associated via the `for` attribute or by nesting.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label
+ */
+export * as label from './label';
+/**
+ * `<legend>` element factory namespace.
+ *
+ * Represents a caption for the content of its parent `<fieldset>`, providing an
+ * accessible label for grouped controls.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/legend
+ */
+export * as legend from './legend';
+/**
+ * `<meter>` element factory namespace.
+ *
+ * Represents a scalar measurement within a known range, or a fractional value.
+ * Use `<progress>` instead for progress over time.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meter
+ */
+export * as meter from './meter';
+/**
+ * `<optgroup>` element factory namespace.
+ *
+ * Represents a grouping of `<option>` elements within a `<select>` or
+ * `<datalist>`.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/optgroup
+ */
+export * as optgroup from './optgroup';
+/**
+ * `<option>` element factory namespace.
+ *
+ * Represents an item within a `<select>`, `<datalist>`, or `<optgroup>`.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/option
+ */
+export * as option from './option';
+/**
+ * `<output>` element factory namespace.
+ *
+ * Represents the result of a calculation or user action, commonly used in
+ * forms to display derived values.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/output
+ */
+export * as output from './output';
+/**
+ * `<progress>` element factory namespace.
+ *
+ * Represents the completion progress of a task, typically over time.
+ * Use `<meter>` instead for a measurement within a known range.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/progress
+ */
+export * as progress from './progress';
+/**
+ * `<select>` element factory namespace.
+ *
+ * Represents a control that provides a menu of options for the user to choose
+ * from.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/select
+ */
+export * as select from './select';
+/**
+ * `<textarea>` element factory namespace.
+ *
+ * Represents a multi-line plain-text editing control.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/textarea
+ */
+export * as textarea from './textarea';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/elements/form/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC;;;;;;;GAOG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC;;;;;;;GAOG;AACH,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAE/B;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC;;;;;;;GAOG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC;;;;;;GAMG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC;;;;;;;GAOG;AACH,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;;;;GAMG;AACH,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC"}