@vastare/fundatio 0.1.0

package/src/elements/inline/small/index.ts

@@ -0,0 +1,177 @@
+/**
+ * Fundatio Design Foundation: Small element helpers.
+ *
+ * @remarks
+ * The small element (`<small>`) represents side comments and small print.
+ *
+ * Best-practice guidance:
+ * - Use `<small>` for side notes, disclaimers, legal restrictions, copyright,
+ *   attribution, or licensing text.
+ * - Do not use `<small>` purely to make text visually smaller. Use CSS when the
+ *   intent is presentational rather than semantic.
+ * - Keep accessible meaning intact: if the content is important, it should be
+ *   readable and not "hidden" behind styling choices.
+ *
+ * Attributes:
+ * - `<small>` has no element-specific attributes in HTML. It accepts global
+ *   attributes only.
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create `<small>` 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.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/small
+ *
+ * @module
+ * @category Elements
+ */
+
+import { createElement, 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 the small element.
+ *
+ * @category Constants
+ */
+export const SMALL_TAG = 'small' as const;
+
+/**
+ * A CSS selector targeting small elements.
+ *
+ * @category Constants
+ */
+export const SMALL_SELECTOR = 'small';
+
+/**
+ * Attribute bag for small creation/enhancement.
+ *
+ * @remarks
+ * `<small>` accepts 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.
+ *
+ * Security note:
+ * - Inline event handler attributes (e.g. `onclick`) are blocked by `dom.ts`.
+ * - The raw `style` attribute is blocked; use {@link GlobalAttrs.style}.
+ *
+ * @category Attributes
+ */
+export type SmallAttrs = Omit<GlobalAttrs, 'aria'> & {
+  /**
+   * Structured ARIA fields mapped into `aria-*` attributes.
+   */
+  aria?: StructuredAria;
+};
+
+/**
+ * Normalize {@link SmallAttrs} into {@link GlobalAttrs} for `dom.ts`.
+ *
+ * @param attrs - The small attributes.
+ * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.
+ *
+ * @category Internal
+ */
+function toGlobalAttrs(attrs?: SmallAttrs): GlobalAttrs | undefined {
+  if (!attrs) return undefined;
+
+  const { aria, ...rest } = attrs;
+
+  if (!aria) return rest;
+
+  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};
+
+  if (typeof aria.label === 'string') mappedAria.label = aria.label;
+  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;
+  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;
+
+  const hasMapped = Object.keys(mappedAria).length > 0;
+
+  return hasMapped ? { ...rest, aria: mappedAria } : rest;
+}
+
+/**
+ * Create a small 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.
+ *
+ * Note: `<small>` is phrasing content. This helper supports a simple `text`
+ * convenience for cases where plain text is sufficient; consumers can still
+ * append richer child nodes afterwards.
+ *
+ * @param text - Optional text content for the small element.
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<small>` element.
+ *
+ * @example
+ * ```ts
+ * import { createSmall } from "@Vastare/Fundatio/elements/inline/small";
+ *
+ * const legal = createSmall("Terms apply.", { className: "legal" });
+ * document.body.appendChild(legal);
+ * ```
+ *
+ * @category DOM
+ */
+export function createSmall(text?: string, attrs?: SmallAttrs): ElementOf<typeof SMALL_TAG> {
+  return createElement(SMALL_TAG, toGlobalAttrs(attrs), text);
+}
+
+/**
+ * Enhance small 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 function enhanceSmalls(root: ParentNode = document): void {
+  // v1.0.0: no runtime behavior for small.
+  void root;
+}

package/src/elements/inline/small/small.scss

@@ -0,0 +1,35 @@
+/**
+ * Fundatio Design Foundation: Small Element
+ *
+ * Side comments / fine print (`small`)
+ *
+ * Baseline reset + light branding.
+ *
+ * This module:
+ * - Preserves semantic meaning (fine print, side comments)
+ * - Normalizes font-size explicitly instead of relying on UA relative scaling
+ * - Maintains readability via inherited typography tokens
+ * - Uses low-specificity selectors (`:where()`)
+ *
+ * @module
+ * @group  elements.inline.small
+ * @access public
+ * @since  1.0.0
+ */
+
+:where(small) {
+  /* --------------------------------------------------------------------------
+   - Reset / normalization
+   -------------------------------------------------------------------------- */
+
+  display: inline;
+
+  // Normalize relative scaling explicitly (UA commonly uses 80%)
+  font-size: 0.875em;
+
+  // Preserve inherited typography context
+  font-family: inherit;
+  font-weight: inherit;
+  line-height: inherit;
+  color: inherit;
+}

package/src/elements/inline/strong/index.ts

@@ -0,0 +1,166 @@
+/**
+ * Fundatio Design Foundation: Strong element helpers.
+ *
+ * @remarks
+ * The strong element (`<strong>`) indicates that its contents have strong
+ * importance, seriousness, or urgency. Browsers typically render it as bold,
+ * but the semantic meaning is what matters. :contentReference[oaicite:3]{index=3}
+ *
+ * Best-practice guidance:
+ * - Use `<strong>` for genuinely important text (e.g. warnings, urgent notes).
+ * - Do not use `<strong>` purely for visual styling; use CSS for presentation.
+ * - Do not confuse `<strong>` with `<b>`:
+ *   - `<strong>` conveys importance/seriousness/urgency.
+ *   - `<b>` draws attention without adding semantic importance. :contentReference[oaicite:4]{index=4}
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create strong text nodes 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.
+ *
+ * @module
+ * @category Elements
+ */
+
+import { createElement, 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 strong importance.
+ *
+ * @category Constants
+ */
+export const STRONG_TAG = 'strong' as const;
+
+/**
+ * A CSS selector targeting strong elements.
+ *
+ * @category Constants
+ */
+export const STRONG_SELECTOR = 'strong';
+
+/**
+ * Attribute bag for strong creation/enhancement.
+ *
+ * @remarks
+ * The `<strong>` element uses 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 StrongAttrs = Omit<GlobalAttrs, 'aria'> & {
+  /**
+   * Structured ARIA fields mapped into `aria-*` attributes.
+   */
+  aria?: StructuredAria;
+};
+
+/**
+ * Normalize {@link StrongAttrs} into {@link GlobalAttrs} for `dom.ts`.
+ *
+ * @param attrs - The strong attributes.
+ * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.
+ *
+ * @category Internal
+ */
+function toGlobalAttrs(attrs?: StrongAttrs): GlobalAttrs | undefined {
+  if (!attrs) return undefined;
+
+  const { aria, ...rest } = attrs;
+
+  if (!aria) return rest;
+
+  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};
+
+  if (typeof aria.label === 'string') mappedAria.label = aria.label;
+  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;
+  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;
+
+  // Only attach `aria` if something was actually defined.
+  const hasMapped = Object.keys(mappedAria).length > 0;
+
+  return hasMapped ? { ...rest, aria: mappedAria } : rest;
+}
+
+/**
+ * Create a strong element with optional text content and global 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 strong element.
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<strong>` element.
+ *
+ * @example
+ * Emphasize a warning:
+ * ```ts
+ * import { createStrong } from "@Vastare/Fundatio/elements/inline/strong";
+ *
+ * const warning = createStrong("Warning:", { className: "warning-label" });
+ * document.body.appendChild(warning);
+ * ```
+ *
+ * @category DOM
+ */
+export function createStrong(text?: string, attrs?: StrongAttrs): ElementOf<typeof STRONG_TAG> {
+  return createElement(STRONG_TAG, toGlobalAttrs(attrs), text);
+}
+
+/**
+ * Enhance strong 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 function enhanceStrongs(root: ParentNode = document): void {
+  // v1.0.0: no runtime behavior for strong.
+  void root;
+}

package/src/elements/inline/strong/strong.scss

@@ -0,0 +1,35 @@
+/**
+ * Fundatio Design Foundation: Strong Element
+ *
+ * Strong importance (`strong`)
+ *
+ * Baseline reset + light branding.
+ *
+ * This module:
+ * - Preserves semantic strong importance
+ * - Normalizes font-weight using Fundatio typography tokens
+ * - Avoids reliance on UA "bolder" calculations
+ * - Uses low-specificity selectors (`:where()`)
+ *
+ * @module
+ * @group  elements.inline.strong
+ * @access public
+ * @since  1.0.0
+ */
+
+:where(strong) {
+  /* --------------------------------------------------------------------------
+   - Reset / normalization
+   -------------------------------------------------------------------------- */
+
+  display: inline;
+
+  // Normalize to explicit token rather than UA relative "bolder"
+  font-weight: var(--lg-typography-font-weights-bold-font-weight);
+
+  // Preserve inherited typography otherwise
+  font-family: inherit;
+  font-size: inherit;
+  line-height: inherit;
+  color: inherit;
+}

package/src/elements/inline/sub/index.ts

@@ -0,0 +1,170 @@
+/**
+ * Fundatio Design Foundation: Sub element helpers.
+ *
+ * @remarks
+ * The sub element (`<sub>`) represents subscript text.
+ *
+ * Best-practice guidance:
+ * - Use `<sub>` for typographical conventions (e.g. chemical formulas like H₂O,
+ *   mathematical indices in plain text, footnote markers) where subscript is
+ *   semantically appropriate.
+ * - Do not use `<sub>` purely for presentation. Use CSS for visual styling.
+ *
+ * The `<sub>` element has no element-specific attributes. It supports standard
+ * HTML global attributes.
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create sub 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.
+ *
+ * MDN:
+ * - https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/sub
+ *
+ * @module
+ * @category Elements
+ */
+
+import { createElement, 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 subscript text.
+ *
+ * @category Constants
+ */
+export const SUB_TAG = 'sub' as const;
+
+/**
+ * A CSS selector targeting sub elements.
+ *
+ * @category Constants
+ */
+export const SUB_SELECTOR = 'sub';
+
+/**
+ * Attribute bag for sub creation/enhancement.
+ *
+ * @remarks
+ * The `<sub>` element accepts 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 SubAttrs = Omit<GlobalAttrs, 'aria'> & {
+  /**
+   * Structured ARIA fields mapped into `aria-*` attributes.
+   */
+  aria?: StructuredAria;
+};
+
+/**
+ * Normalize {@link SubAttrs} into {@link GlobalAttrs} for `dom.ts`.
+ *
+ * @param attrs - The sub attributes.
+ * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.
+ *
+ * @category Internal
+ */
+function toGlobalAttrs(attrs?: SubAttrs): GlobalAttrs | undefined {
+  if (!attrs) return undefined;
+
+  const { aria, ...rest } = attrs;
+
+  if (!aria) return rest;
+
+  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};
+
+  if (typeof aria.label === 'string') mappedAria.label = aria.label;
+  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;
+  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;
+
+  // Only attach `aria` if something was actually defined.
+  const hasMapped = Object.keys(mappedAria).length > 0;
+
+  return hasMapped ? { ...rest, aria: mappedAria } : rest;
+}
+
+/**
+ * Create a sub element with optional text content and global 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 sub element.
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<sub>` element.
+ *
+ * @example
+ * ```ts
+ * import { createSub } from "@Vastare/Fundatio/elements/inline/sub";
+ *
+ * const formula = document.createElement("span");
+ * formula.append("H");
+ * formula.appendChild(createSub("2"));
+ * formula.append("O");
+ * ```
+ *
+ * @category DOM
+ */
+export function createSub(text?: string, attrs?: SubAttrs): ElementOf<typeof SUB_TAG> {
+  return createElement(SUB_TAG, toGlobalAttrs(attrs), text);
+}
+
+/**
+ * Enhance sub 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 function enhanceSubs(root: ParentNode = document): void {
+  // v1.0.0: no runtime behavior for sub.
+  void root;
+}

package/src/elements/inline/sub/sub.scss

@@ -0,0 +1,44 @@
+/**
+ * Fundatio Design Foundation: Sub Element
+ *
+ * Subscript (`sub`)
+ *
+ * Baseline reset + normalized subscript behavior.
+ *
+ * Notes:
+ * - `<sub>` lowers text relative to baseline.
+ * - Normalize font-size and vertical positioning explicitly.
+ * - Preserve readability and inline flow.
+ *
+ * References (2025+):
+ * - MDN: `<sub>` element reference (Sep 2025)
+ * - CSS Inline Layout Module guidance
+ *
+ * @module
+ * @group  elements.inline.sub
+ * @access public
+ * @since  1.0.0
+ */
+
+:where(sub) {
+  /* --------------------------------------------------------------------------
+   - Reset / normalization
+   -------------------------------------------------------------------------- */
+
+  display: inline;
+
+  // Explicit scaling instead of relying on UA "smaller"
+  font-size: 0.75em;
+
+  // Maintain inline readability
+  line-height: 0;
+
+  // Normalize vertical shift
+  vertical-align: sub;
+
+  // Preserve inherited typography context
+  font-family: inherit;
+  font-style: inherit;
+  font-weight: inherit;
+  color: inherit;
+}