@rak200/ui 0.3.0 → 0.4.0

package/dist/input.js

@@ -1,4 +1,4 @@
-import { LitElement, css, html } from 'lit';
+import { LitElement, css, html, nothing } from 'lit';
 import { reference } from './reference.js';
 /**
  * What a styled native control looks like, which both elements share.
@@ -6,24 +6,32 @@ import { reference } from './reference.js';
  * One stylesheet naming both `input` and `textarea` rather than one per element: the two
  * differ in what they accept and in one rule about resizing, and duplicating the whole
  * box to express that would be two copies of a contract with nothing comparing them.
+ *
+ * **Every rule reaches a control this element renders**, which RFC 0005 decided. The
+ * `::slotted()` these rules were written with was forced by the control having to sit in
+ * the host's tree, where the label could reach it — and what a relationship actually needs
+ * is for every end of it to share a tree scope, which a `<label for>` and its control in
+ * one shadow root satisfy. So the label, the help and the error came inside with it.
  */
-const control = css `
+const field = css `
     :host {
         display: block;
+        font-family: ${reference('--ui-font')};
     }
 
-    /* Everything below reaches a control the *host* wrote, through ::slotted. That is the
-       whole shape of this component and it is forced rather than preferred — the control
-       has to stay in the light DOM, where the label and the description ui-field writes
-       can resolve against it. Measured, in this suite's own instrument: the same control
-       rendered into a shadow root is an axe label violation at critical impact, and the
-       aria-describedby pointing at it dangles.
+    /* The rhythm ui-field used to own, now owned by the control it was wrapping. */
+    .stack {
+        display: flex;
+        flex-direction: column;
+        gap: calc(${reference('--ui-space')} / 2);
+    }
+
+    label {
+        color: ${reference('--ui-color-text')};
+    }
 
-       ::slotted reaches a pseudo-element of a slotted node too, which is what makes the
-       placeholder rule below possible — measured, because the selector looks like it
-       should not work. */
-    ::slotted(input),
-    ::slotted(textarea) {
+    input,
+    textarea {
         box-sizing: border-box;
         inline-size: 100%;
         font: inherit;
@@ -40,8 +48,8 @@ const control = css `
             ${reference('--ui-easing-state')};
     }
 
-    ::slotted(input)::placeholder,
-    ::slotted(textarea)::placeholder {
+    input::placeholder,
+    textarea::placeholder {
         color: ${reference('--ui-color-text-muted')};
         /* Firefox lowers a placeholder's opacity by default, which would take the colour
            below the 4.5:1 it was chosen to clear — a contrast floor undone by a rule
@@ -56,98 +64,381 @@ const control = css `
        The guards are measured rather than assumed, the same way ui-button's are: a
        disabled control still matches :hover, and a readonly one accepts a pointer it will
        do nothing with. */
-    ::slotted(input:hover:not(:disabled):not([readonly])),
-    ::slotted(textarea:hover:not(:disabled):not([readonly])) {
+    input:hover:not(:disabled):not([readonly]),
+    textarea:hover:not(:disabled):not([readonly]) {
         border-color: ${reference('--ui-color-text')};
     }
 
     /* A visible focus ring is not decoration: removing it is the single most common way a
        component stops being usable by keyboard. */
-    ::slotted(input:focus-visible),
-    ::slotted(textarea:focus-visible) {
+    input:focus-visible,
+    textarea:focus-visible {
         outline: 2px solid ${reference('--ui-color-focus')};
         outline-offset: 2px;
     }
 
-    ::slotted(input:disabled),
-    ::slotted(textarea:disabled) {
+    input:disabled,
+    textarea:disabled {
         cursor: not-allowed;
         opacity: 0.5;
     }
 
-    /* The error state is not this component's to decide, and it does not decide it:
-       ui-field sets aria-invalid on the control as part of the wiring it already
-       owns, and this rule reads it. So the message under the field and the box around it
-       cannot disagree about whether there is an error — there is one source and it is the
-       one a screen reader is already using. */
-    ::slotted(input[aria-invalid='true']),
-    ::slotted(textarea[aria-invalid='true']) {
+    :host([disabled]) label {
+        color: ${reference('--ui-color-text-muted')};
+    }
+
+    /* Read off the control's own aria-invalid rather than off a host attribute: it is the
+       same source a screen reader uses, and it is the rule this file already carried when
+       ui-field was the one writing it. Not :host([error]) — a reflected string property
+       whose default is empty puts an empty attribute on the host, and an
+       attribute-presence selector matches every element. Measured on ui-checkbox. */
+    input[aria-invalid='true'],
+    textarea[aria-invalid='true'] {
         border-color: ${reference('--ui-color-danger')};
     }
+
+    .help {
+        color: ${reference('--ui-color-text')};
+        font-size: ${reference('--ui-text-supporting')};
+    }
+
+    /* Colour is not the only cue — the message says what is wrong, and aria-invalid marks
+       the control whatever the styling does. */
+    .error {
+        color: ${reference('--ui-color-danger')};
+        font-size: ${reference('--ui-text-supporting')};
+    }
 `;
 /**
- * A styled native form control.
+ * Omitted rather than written blank, which is a rule and not a preference.
  *
- * The control is the host's own, slotted in rather than rendered here, and that is the
- * single decision this component is made of. {@link UiInput} and {@link UiTextarea} carry
- * the appearance; the element inside carries everything else.
+ * An empty attribute is not a neutral one: `pattern=""` is the empty expression and
+ * matches only the empty string, so a field carrying it is invalid for every value a
+ * person can type. Measured, as a control that reported `patternMismatch` with no pattern
+ * in sight. The same shape bit `<ui-checkbox>` from the other side, where `error=""`
+ * matched an attribute-presence selector on every element.
  */
-class UiControl extends LitElement {
-    render() {
-        return html `<slot></slot>`;
-    }
+function attribute(value) {
+    return value === '' ? nothing : value;
 }
 /**
- * A text input, styled by the token layer rather than replaced.
+ * A styled native form control, and the wiring that used to sit around it.
+ *
+ * **The control is this element's**, rendered into its shadow root together with its
+ * label, its help text and its message — so the IDREFs resolve in one tree scope and
+ * `<ui-field>` has nothing left to point at. What a host writes is the tag and its
+ * attributes.
  *
- * **The `<input>` is yours.** You write it, you set its attributes, and it stays in the
- * light DOM — so `type`, `required`, `readonly`, `name` and `value` are the platform's
- * business and there is no pass-through layer to fall out of step with them. It reaches a
- * form submit for the same reason: a native control inside a `<form>` participates
- * because it is a native control inside a `<form>`, with no `ElementInternals` and no
- * value mirroring. That was the open question on the issue, and the answer is that the
- * shape the accessibility rule forced happens to be the shape that answers it.
+ * **The element is the form control**, through `ElementInternals`: an `<input>` in a
+ * shadow root has no form owner, so the value reaches a submit because this element passes
+ * it on. **Constraint validation is not reimplemented** — the inner control still computes
+ * its own, `type="email"` and `min` and `pattern` included, and this element hands the
+ * whole `ValidityState` over with the message the engine wrote. Measured: a bad address
+ * reports `typeMismatch` with the browser's own wording.
+ */
+class UiTextField extends LitElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * The accessible name, and the text above the control.
+         *
+         * A plain field rather than the `accessor` keyword, for the reason `src/button.ts`
+         * gives beside its own — and so for every property below.
+         */
+        this.label = '';
+        /** Supporting text under the control, which survives an error rather than yielding. */
+        this.help = '';
+        /** The message, which paints the boundary and is announced with the control. */
+        this.error = '';
+        /**
+         * The name the value is submitted under.
+         *
+         * **Reflected, and that is a requirement rather than a convenience.** A form names a
+         * form-associated custom element's entry from the content attribute, so a host who set
+         * only the property would submit nothing at all — silently.
+         */
+        this.name = '';
+        /**
+         * What the control holds.
+         *
+         * **Not reflected**, the way a native control's `value` IDL attribute is not: the
+         * content attribute is the *default* a reset returns to, and one that followed every
+         * keystroke would make the default whatever was last typed.
+         */
+        this.value = '';
+        /** The hint inside an empty control, which is never a substitute for the label. */
+        this.placeholder = '';
+        /** What the browser may fill this with. Empty means the attribute is not written. */
+        this.autocomplete = '';
+        /** The shortest accepted value, as the attribute spells it. */
+        this.minlength = '';
+        /** The longest accepted value, likewise. */
+        this.maxlength = '';
+        /** Whether a form is invalid while the control is empty. */
+        this.required = false;
+        /** Whether the control refuses interaction, and submits nothing. */
+        this.disabled = false;
+        /** Whether the control shows a value it will not let you change. */
+        this.readonly = false;
+        this.#internals = this.attachInternals();
+        /**
+         * Mirrors what the person typed back into the property it came from.
+         *
+         * `input` is composed and leaves the shadow root on its own, retargeted to this
+         * element; `change` is not, so the one the control fires stops at the boundary and is
+         * re-dispatched. Measured on `<ui-checkbox>`, and the same both times.
+         */
+        this.typed = (event) => {
+            this.value = event.target.value;
+        };
+        this.changed = () => {
+            this.dispatchEvent(new Event('change', { bubbles: true }));
+        };
+    }
+    static { this.formAssociated = true; }
+    /**
+     * Focus is delegated, so `focus()` and `reportValidity()` reach the control.
+     *
+     * Neither is optional: the host is not a focusable element, and the second is what the
+     * browser calls itself when a form with an invalid control is submitted. Measured, on
+     * `<ui-checkbox>` first.
+     */
+    static { this.shadowRootOptions = {
+        ...LitElement.shadowRootOptions,
+        delegatesFocus: true,
+    }; }
+    static { this.properties = {
+        label: { type: String, reflect: true },
+        help: { type: String, reflect: true },
+        error: { type: String, reflect: true },
+        name: { type: String, reflect: true },
+        // Stryker disable next-line ObjectLiteral: `{}` is what Lit's default converter
+        // already does for a string — `type` only switches the converter for Boolean,
+        // Number, Object and Array — and `reflect` defaults to false either way. The
+        // declaration is written out to say which of the two `value` is, not to change it.
+        value: { type: String },
+        placeholder: { type: String, reflect: true },
+        autocomplete: { type: String, reflect: true },
+        minlength: { type: String, reflect: true },
+        maxlength: { type: String, reflect: true },
+        required: { type: Boolean, reflect: true },
+        disabled: { type: Boolean, reflect: true },
+        readonly: { type: Boolean, reflect: true },
+    }; }
+    #internals;
+    /** The validity, taken from the control that computed it. */
+    #publish(control) {
+        if (this.error !== '') {
+            this.#internals.setValidity({ customError: true }, this.error, control);
+            return;
+        }
+        // The whole ValidityState, handed over as the platform computed it — so `min`,
+        // `pattern`, `type="email"` and whatever the platform adds next are validated by
+        // the thing that already knows how, with the message it already wrote.
+        this.#internals.setValidity(control.validity, control.validationMessage, control);
+    }
+    /**
+     * The value and the validity, which move together here or disagree anywhere.
+     *
+     * **Iterated rather than asserted**, and there is exactly one control to iterate:
+     * `render()` puts it there unconditionally. Written as a query and a null check, the
+     * check would be a branch no test could reach — which is a coverage hole and an
+     * immortal mutant at once, rather than safety. A loop over what was rendered is total.
+     */
+    updated() {
+        this.#internals.setFormValue(this.value);
+        for (const control of this.renderRoot.querySelectorAll('input, textarea')) {
+            this.#publish(control);
+        }
+    }
+    /**
+     * A form reset, which returns to the content attribute — `defaultValue` exactly, and
+     * a usable default only because `value` is not reflected onto it.
+     */
+    formResetCallback() {
+        this.value = this.getAttribute('value') ?? '';
+    }
+    /** A `<fieldset disabled>` above this element, which reaches it and nothing below. */
+    formDisabledCallback(disabled) {
+        this.disabled = disabled;
+    }
+    /** Restoring after a back-navigation, where the browser hands the value back. */
+    formStateRestoreCallback(state) {
+        this.value = state ?? '';
+    }
+    /** The form this element participates in, for a host that needs it. */
+    get form() {
+        return this.#internals.form;
+    }
+    /** Whether the control currently satisfies its constraints. */
+    get validity() {
+        return this.#internals.validity;
+    }
+    /** The message a form would report for it, empty while the control is valid. */
+    get validationMessage() {
+        return this.#internals.validationMessage;
+    }
+    /**
+     * The label, the help and the message, with the control between them.
+     *
+     * The control is passed in rather than produced by an overridable hook, for the reason
+     * `src/checkbox.ts` gives at its own: a hook whose base implementation returns a
+     * default cannot be told from one that returns nothing, and the mutation floor is what
+     * reports the difference.
+     *
+     * **The error is described before the help**, and the help is not replaced by it: a
+     * screen reader announces descriptions in order, and help text is usually the format
+     * requirement — which is the very suggestion a reader needs in order to recover
+     * (WCAG 3.3.3). `<ui-field>` decided that and this carries it.
+     */
+    frame(control) {
+        return html `
+            <div class="stack" part="stack">
+                <label for="control" part="label">${this.label}</label>
+                ${control}
+                ${this.help === ''
+            ? nothing
+            : html `<span class="help" id="help" part="help">${this.help}</span>`}
+                ${this.error === ''
+            ? nothing
+            : html `<span class="error" id="error" part="error">${this.error}</span>`}
+            </div>
+        `;
+    }
+    /** The ids describing the control, in the order a reader needs them. */
+    described() {
+        return attribute([this.error === '' ? '' : 'error', this.help === '' ? '' : 'help']
+            .filter((id) => id !== '')
+            .join(' '));
+    }
+    /** Whether the control announces itself as invalid, which the boundary reads. */
+    invalid() {
+        return this.error === '' ? nothing : 'true';
+    }
+}
+/**
+ * A text input, drawn from the token layer rather than replaced.
  *
- * Composes with {@link UiField}, which finds the control through this wrapper and wires
- * the label, the help, the error and `aria-invalid` to it.
+ * **You write the tag, not a control.** RFC 0005 reversed the rule this element was built
+ * on: the `<input>`, its `<label>`, its help text and its message are rendered together in
+ * one shadow root, so the IDREFs resolve and there is nothing left for `<ui-field>` to
+ * wire. The attributes below are the platform's own, and the ones it computes with —
+ * `type`, `pattern`, `min`, `max`, `step` — are handed to a real `<input>` that validates
+ * them itself.
  *
  * @example
  * ```html
- * <ui-field>
- *   <label slot="label">Amount</label>
- *   <ui-input><input type="number" name="amount" /></ui-input>
- *   <span slot="help">In BRL, two decimals.</span>
- * </ui-field>
+ * <ui-input label="Amount" help="In BRL, two decimals." type="number" name="amount"></ui-input>
  * ```
  */
-export class UiInput extends UiControl {
-    static { this.styles = control; }
+export class UiInput extends UiTextField {
+    constructor() {
+        super(...arguments);
+        /** Which control the platform draws, and which constraints it then applies. */
+        this.type = 'text';
+        /** Which keyboard a touch device offers, where `type` is not the right lever. */
+        this.inputmode = '';
+        /** The expression the value must match. Empty means no attribute is written. */
+        this.pattern = '';
+        /** The lowest accepted value, likewise. */
+        this.min = '';
+        /** The highest accepted value, likewise. */
+        this.max = '';
+        /** The granularity the value must fall on, likewise. */
+        this.step = '';
+    }
+    static { this.styles = field; }
+    static { this.properties = {
+        ...UiTextField.properties,
+        type: { type: String, reflect: true },
+        inputmode: { type: String, reflect: true },
+        pattern: { type: String, reflect: true },
+        min: { type: String, reflect: true },
+        max: { type: String, reflect: true },
+        step: { type: String, reflect: true },
+    }; }
+    render() {
+        return this.frame(html `
+            <input
+                id="control"
+                part="control"
+                type=${this.type}
+                .value=${this.value}
+                name=${attribute(this.name)}
+                placeholder=${attribute(this.placeholder)}
+                autocomplete=${attribute(this.autocomplete)}
+                inputmode=${attribute(this.inputmode)}
+                pattern=${attribute(this.pattern)}
+                minlength=${attribute(this.minlength)}
+                maxlength=${attribute(this.maxlength)}
+                min=${attribute(this.min)}
+                max=${attribute(this.max)}
+                step=${attribute(this.step)}
+                ?required=${this.required}
+                ?disabled=${this.disabled}
+                ?readonly=${this.readonly}
+                aria-invalid=${this.invalid()}
+                aria-describedby=${this.described()}
+                @input=${this.typed}
+                @change=${this.changed}
+            />
+        `);
+    }
 }
 /**
- * A multi-line text control, styled by the token layer rather than replaced.
+ * A multi-line text control, drawn from the token layer rather than replaced.
  *
- * Everything {@link UiInput} says applies. What differs is two rules: a height to start
- * at, and resizing left on the vertical axis — a control that cannot grow is one people
- * fight, and one that grows sideways breaks the layout around it.
+ * Everything {@link UiInput} says applies. What differs is two rules — a height to start
+ * at, and resizing left on the vertical axis, because a control that cannot grow is one
+ * people fight and one that grows sideways breaks the layout around it — and that a
+ * `<textarea>` has no `type` and no `pattern` to validate against.
  *
  * @example
  * ```html
- * <ui-field>
- *   <label slot="label">Notes</label>
- *   <ui-textarea><textarea name="notes" rows="4"></textarea></ui-textarea>
- * </ui-field>
+ * <ui-textarea label="Notes" name="notes" rows="4"></ui-textarea>
  * ```
  */
-export class UiTextarea extends UiControl {
+export class UiTextarea extends UiTextField {
+    constructor() {
+        super(...arguments);
+        /** How many lines the control starts at. Empty leaves the platform's own default. */
+        this.rows = '';
+    }
     static { this.styles = [
-        control,
+        field,
         css `
-            ::slotted(textarea) {
+            textarea {
                 min-block-size: calc(${reference('--ui-space')} * 10);
                 resize: vertical;
             }
         `,
     ]; }
+    static { this.properties = {
+        ...UiTextField.properties,
+        rows: { type: String, reflect: true },
+    }; }
+    render() {
+        return this.frame(html `
+            <textarea
+                id="control"
+                part="control"
+                .value=${this.value}
+                name=${attribute(this.name)}
+                placeholder=${attribute(this.placeholder)}
+                autocomplete=${attribute(this.autocomplete)}
+                minlength=${attribute(this.minlength)}
+                maxlength=${attribute(this.maxlength)}
+                rows=${attribute(this.rows)}
+                ?required=${this.required}
+                ?disabled=${this.disabled}
+                ?readonly=${this.readonly}
+                aria-invalid=${this.invalid()}
+                aria-describedby=${this.described()}
+                @input=${this.typed}
+                @change=${this.changed}
+            ></textarea>
+        `);
+    }
 }
 // Stryker disable next-line StringLiteral: the registration runs once, at import, inside
 // the warm process Stryker switches mutants in — so by the time a mutant on this line is

package/dist/input.js.map

@@ -1 +1 @@
-{"version":3,"file":"input.js","sourceRoot":"","sources":["../src/input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAuC,MAAM,KAAK,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,OAAO,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;uBAoBI,SAAS,CAAC,WAAW,CAAC;iBAC5B,SAAS,CAAC,iBAAiB,CAAC;sBACvB,SAAS,CAAC,oBAAoB,CAAC;4BACzB,SAAS,CAAC,mBAAmB,CAAC;yBACjC,SAAS,CAAC,aAAa,CAAC;mBAC9B,SAAS,CAAC,YAAY,CAAC;;;;mCAIP,SAAS,CAAC,qBAAqB,CAAC;cACrD,SAAS,CAAC,mBAAmB,CAAC;;;;;iBAK3B,SAAS,CAAC,uBAAuB,CAAC;;;;;;;;;;;;;;;;wBAgB3B,SAAS,CAAC,iBAAiB,CAAC;;;;;;;6BAOvB,SAAS,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;wBAiBlC,SAAS,CAAC,mBAAmB,CAAC;;CAErD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,SAAU,SAAQ,UAAU;IACrB,MAAM;QACX,OAAO,IAAI,CAAA,eAAe,CAAC;IAC/B,CAAC;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAO,OAAQ,SAAQ,SAAS;aACT,WAAM,GAAc,OAAO,CAAC;;AAGzD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,UAAW,SAAQ,SAAS;aACZ,WAAM,GAAgB;QAC3C,OAAO;QACP,GAAG,CAAA;;uCAE4B,SAAS,CAAC,YAAY,CAAC;;;SAGrD;KACJ,CAAC;;AAGN,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,oEAAoE;AACpE,cAAc,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAE3C,0EAA0E;AAC1E,cAAc,CAAC,MAAM,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC"}
+{"version":3,"file":"input.js","sourceRoot":"","sources":["../src/input.ts"],"names":[],"mappings":"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"}