@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/tool-param-form/tool-param-form.d.ts

@@ -1,145 +1,5 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-import '../select/select.js';
-import '../combobox/option.js';
-import '../checkbox/checkbox.js';
-/** The four leaf property types this phase's flat-schema renderer understands. */
-export type ToolParamFormPropertyType = 'string' | 'number' | 'integer' | 'boolean';
-/**
- * One `schema.properties` entry. Deliberately shallow — see the class doc for
- * the full scope limitation this type encodes.
- */
-export interface ToolParamFormProperty {
-    type: ToolParamFormPropertyType;
-    /** A closed set of string choices, rendered as a `<lyra-select>`. Only meaningful when `type` is `'string'`. */
-    enum?: string[];
-    /** Helper text rendered under the field. */
-    description?: string;
-    /** Display label. Falls back to the property key itself when omitted. */
-    title?: string;
-    /** Pre-filled value used whenever `value` doesn't already have this key. */
-    default?: unknown;
-}
-/**
- * The (intentionally flat) JSON Schema subset this component can render:
- * a plain object whose every property is a string, number/integer, boolean,
- * or string enum. See the class doc for what's out of scope.
- */
-export interface ToolParamFormSchema {
-    type: 'object';
-    properties: Record<string, ToolParamFormProperty>;
-    required?: string[];
-}
-/**
- * `<lyra-tool-param-form>` — renders one form control per top-level property
- * of a JSON Schema object, for ad hoc tool invocation or approval-editing UIs
- * (e.g. "the agent wants to call `create_event(title, attendees, allDay)` —
- * let the user tweak the arguments before running it").
- *
- * **Scope limitation (intentional, not accidental):** this phase only
- * understands a *flat* object schema — every `properties` entry must be
- * `'string'`, `'number'`, `'integer'`, `'boolean'`, or a string `enum`.
- * Nested objects, arrays, `oneOf`/`anyOf`/`allOf`, `$ref`, and any other
- * JSON Schema keyword are not read. A full JSON-Schema-to-form renderer is
- * out of scope for this component; a property whose `type` isn't one of the
- * four above renders a visible "Unsupported field type" note instead of
- * silently dropping it or throwing.
- *
- * Fields render in `Object.keys(schema.properties)` order (insertion order,
- * which is reliable for a plain object's string keys). A field's label is
- * `title ?? ` the property key; `description` renders as helper text below
- * the control; a key listed in `required` gets a visible `*` and the
- * underlying control's own `required` wiring.
- *
- * This component owns no Submit/Cancel/Approve chrome — a consumer composes
- * it inside their own dialog (e.g. a tool-approval dialog) and reads
- * `.value`/`.errors`/`checkValidity()` (or calls `reportValidity()` right
- * before acting, which also reveals any inline errors that user interaction
- * hasn't surfaced yet).
- *
- * `value` is exactly what the consumer last set it to — a field with no
- * entry in `value` but a schema `default` displays (and is *emitted*, via
- * `lyra-input`) as that default, but the `value` *property* itself is left
- * alone until the user actually edits that field. This mirrors an
- * uncontrolled `<input placeholder>` not writing to `.value`, and means the
- * very first `lyra-input` a consumer receives already carries every default
- * resolved, so round-tripping `e.detail.value` back into `.value` converges
- * after one edit.
- *
- * Optional native `<form>` participation is implemented via `ElementInternals`
- * attached directly (this component's value is a whole object, not a plain
- * string, so the `FormAssociated` string-value mixin doesn't fit — same
- * shape as `<lyra-combobox>`'s array-valued case). This is a nice-to-have
- * layered on top of the primary integration contract (`value` +
- * `lyra-input`/`lyra-validity-change`), not a requirement: a consumer that
- * never puts this inside a `<form>` loses nothing.
- *
- * @customElement lyra-tool-param-form
- * @event lyra-input - A field's value changed. `detail: { value }` — the
- * full current value object (every property, defaults resolved), not just
- * the field that changed.
- * @event lyra-validity-change - Overall validity changed (a required field
- * became empty/non-empty). `detail: { valid: boolean; errors: Record<string, string> }`.
- * @csspart base - The outer wrapper around all fields.
- * @csspart field - One property's wrapper (label + control + description + error).
- * @csspart label - A field's label.
- * @csspart description - A field's helper text, from `schema.description`.
- * @csspart error - A field's inline validation message (only rendered once the field has been visited).
- */
-export declare class LyraToolParamForm extends LyraElement {
-    static formAssociated: boolean;
-    static styles: import("lit").CSSResultGroup[];
-    schema: ToolParamFormSchema;
-    value: Record<string, unknown>;
-    /** Submission key for the optional native `<form>` participation — see the class doc. */
-    name: string;
-    disabled: boolean;
-    private _errors;
-    private touchedFields;
-    private internals;
-    private baseId;
-    private lastValidityKey;
-    constructor();
-    connectedCallback(): void;
-    /** `value`, with any property missing from it filled in from `schema`'s own `default` — see the class doc. */
-    get effectiveValue(): Record<string, unknown>;
-    /**
-     * The current per-field validation errors (`{ [propertyKey]: message }`),
-     * required-and-empty only — mirrors the last `lyra-validity-change`
-     * event's `errors`. Independent of which fields have been visited; a
-     * consumer wanting the visited-only, screen-reader-announced subset
-     * should read the rendered `[part="error"]` elements instead.
-     */
-    get errors(): Record<string, string>;
-    /** The current per-field validation errors (required-and-empty only), independent of `touchedFields`. */
-    private computeErrors;
-    /** Non-mutating validity check — unlike `reportValidity()`, never reveals inline errors. */
-    checkValidity(): boolean;
-    /**
-     * Reveals inline errors for every currently-invalid required field (as if
-     * each had been visited) and returns overall validity — the hook a
-     * consumer's own Submit/Approve button should call right before acting,
-     * mirroring a native `<form>`'s `reportValidity()`.
-     */
-    reportValidity(): boolean;
-    formResetCallback(): void;
-    formDisabledCallback(disabled: boolean): void;
-    protected willUpdate(changed: PropertyValues): void;
-    /** Pushes `effectiveValue`/`errors` into `ElementInternals` — see the class doc's form-participation note. */
-    private syncInternals;
-    protected updated(changed: PropertyValues): void;
-    private setFieldValue;
-    private markTouched;
-    private onTextInput;
-    private onNumberInput;
-    private onSelectChange;
-    private onCheckboxChange;
-    private renderControl;
-    private renderField;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-tool-param-form': LyraToolParamForm;
-    }
-}
+export * from './tool-param-form.class.js';
+import "../checkbox/checkbox.js";
+import "../combobox/option.js";
+import "../select/select.js";
+//# sourceMappingURL=tool-param-form.d.ts.map

package/dist/components/tool-param-form/tool-param-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-param-form.d.ts","sourceRoot":"","sources":["../../../src/components/tool-param-form/tool-param-form.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAG3C,OAAO,yBAAyB,CAAC;AACjC,OAAO,uBAAuB,CAAC;AAC/B,OAAO,qBAAqB,CAAC"}

package/dist/components/tool-param-form/tool-param-form.js

@@ -1,366 +1,8 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { html, nothing } from 'lit';
-import { property, state } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './tool-param-form.class.js';
+import { LyraToolParamForm } from './tool-param-form.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { nextId } from '../../internal/a11y.js';
-import { styles } from './tool-param-form.styles.js';
-import '../select/select.js';
-import '../combobox/option.js';
-import '../checkbox/checkbox.js';
-const EMPTY_SCHEMA = { type: 'object', properties: {} };
-/** `true` when `v` counts as "empty" for `prop`'s type, for the one validation rule this phase implements. */
-function isFieldEmpty(prop, v) {
-    if (prop.type === 'boolean') {
-        // A checkbox always holds a concrete true/false once rendered — there's
-        // no third "unset" visual state to represent JSON Schema's "key absent"
-        // meaning. Reusing <lyra-checkbox>'s own required semantics (must be
-        // checked) gives `required` on a boolean field an actually useful
-        // meaning here — e.g. a `confirmDestroy: boolean, required` param — and
-        // matches the control it's composed from instead of inventing a second,
-        // inconsistent definition of "required checkbox".
-        return v !== true;
-    }
-    if (v === undefined || v === null)
-        return true;
-    if (prop.type === 'string')
-        return typeof v !== 'string' || v.trim() === '';
-    // number / integer
-    return typeof v !== 'number' || Number.isNaN(v);
-}
-/**
- * `<lyra-tool-param-form>` — renders one form control per top-level property
- * of a JSON Schema object, for ad hoc tool invocation or approval-editing UIs
- * (e.g. "the agent wants to call `create_event(title, attendees, allDay)` —
- * let the user tweak the arguments before running it").
- *
- * **Scope limitation (intentional, not accidental):** this phase only
- * understands a *flat* object schema — every `properties` entry must be
- * `'string'`, `'number'`, `'integer'`, `'boolean'`, or a string `enum`.
- * Nested objects, arrays, `oneOf`/`anyOf`/`allOf`, `$ref`, and any other
- * JSON Schema keyword are not read. A full JSON-Schema-to-form renderer is
- * out of scope for this component; a property whose `type` isn't one of the
- * four above renders a visible "Unsupported field type" note instead of
- * silently dropping it or throwing.
- *
- * Fields render in `Object.keys(schema.properties)` order (insertion order,
- * which is reliable for a plain object's string keys). A field's label is
- * `title ?? ` the property key; `description` renders as helper text below
- * the control; a key listed in `required` gets a visible `*` and the
- * underlying control's own `required` wiring.
- *
- * This component owns no Submit/Cancel/Approve chrome — a consumer composes
- * it inside their own dialog (e.g. a tool-approval dialog) and reads
- * `.value`/`.errors`/`checkValidity()` (or calls `reportValidity()` right
- * before acting, which also reveals any inline errors that user interaction
- * hasn't surfaced yet).
- *
- * `value` is exactly what the consumer last set it to — a field with no
- * entry in `value` but a schema `default` displays (and is *emitted*, via
- * `lyra-input`) as that default, but the `value` *property* itself is left
- * alone until the user actually edits that field. This mirrors an
- * uncontrolled `<input placeholder>` not writing to `.value`, and means the
- * very first `lyra-input` a consumer receives already carries every default
- * resolved, so round-tripping `e.detail.value` back into `.value` converges
- * after one edit.
- *
- * Optional native `<form>` participation is implemented via `ElementInternals`
- * attached directly (this component's value is a whole object, not a plain
- * string, so the `FormAssociated` string-value mixin doesn't fit — same
- * shape as `<lyra-combobox>`'s array-valued case). This is a nice-to-have
- * layered on top of the primary integration contract (`value` +
- * `lyra-input`/`lyra-validity-change`), not a requirement: a consumer that
- * never puts this inside a `<form>` loses nothing.
- *
- * @customElement lyra-tool-param-form
- * @event lyra-input - A field's value changed. `detail: { value }` — the
- * full current value object (every property, defaults resolved), not just
- * the field that changed.
- * @event lyra-validity-change - Overall validity changed (a required field
- * became empty/non-empty). `detail: { valid: boolean; errors: Record<string, string> }`.
- * @csspart base - The outer wrapper around all fields.
- * @csspart field - One property's wrapper (label + control + description + error).
- * @csspart label - A field's label.
- * @csspart description - A field's helper text, from `schema.description`.
- * @csspart error - A field's inline validation message (only rendered once the field has been visited).
- */
-export class LyraToolParamForm extends LyraElement {
-    static { this.formAssociated = true; }
-    static { this.styles = [LyraElement.styles, styles]; }
-    constructor() {
-        super();
-        this.schema = EMPTY_SCHEMA;
-        this.value = {};
-        /** Submission key for the optional native `<form>` participation — see the class doc. */
-        this.name = '';
-        this.disabled = false;
-        // The true (touched-independent) per-field error set, recomputed in
-        // willUpdate() so it's available to the very same render() pass rather
-        // than lagging a frame behind in updated(). Exposed publicly (read-only)
-        // via the `errors` getter below, under a leading underscore here so the
-        // getter itself can be named plain `errors` without a collision.
-        this._errors = {};
-        // Which fields have been visited (focusout'd) at least once — gates only
-        // the *visual* error/aria-invalid presentation, matching every other
-        // form control in this library (lyra-select/lyra-combobox/lyra-model-select
-        // all avoid flashing red before the user has touched anything).
-        this.touchedFields = new Set();
-        this.baseId = nextId('tool-param-form');
-        this.internals = this.attachInternals();
-    }
-    connectedCallback() {
-        super.connectedCallback();
-        // Seed `errors`/`internals` validity synchronously at connect time —
-        // `checkValidity()`/a wrapping `<form>`'s own `reportValidity()` must
-        // see the correct answer even if called before Lit's first (async)
-        // update has run, mirroring lyra-select's/lyra-checkbox's identical
-        // connectedCallback -> updateValidity() call.
-        this._errors = this.computeErrors();
-        this.syncInternals();
-    }
-    /** `value`, with any property missing from it filled in from `schema`'s own `default` — see the class doc. */
-    get effectiveValue() {
-        const props = this.schema?.properties ?? {};
-        const out = { ...this.value };
-        for (const key of Object.keys(props)) {
-            // `hasOwnProperty`, not `out[key] === undefined` — a number field the
-            // user has explicitly cleared is `{ days: undefined }` (a real own
-            // property, via the `{...this.value, [key]: val}` spread in
-            // setFieldValue()), and must stay cleared rather than silently
-            // snapping back to its default just because its current value also
-            // happens to be `undefined`. Only a key genuinely absent from `value`
-            // (never touched, or reset back to `{}`) falls back to the default.
-            if (!Object.prototype.hasOwnProperty.call(this.value, key) && props[key].default !== undefined) {
-                out[key] = props[key].default;
-            }
-        }
-        return out;
-    }
-    /**
-     * The current per-field validation errors (`{ [propertyKey]: message }`),
-     * required-and-empty only — mirrors the last `lyra-validity-change`
-     * event's `errors`. Independent of which fields have been visited; a
-     * consumer wanting the visited-only, screen-reader-announced subset
-     * should read the rendered `[part="error"]` elements instead.
-     */
-    get errors() {
-        return { ...this._errors };
-    }
-    /** The current per-field validation errors (required-and-empty only), independent of `touchedFields`. */
-    computeErrors() {
-        const props = this.schema?.properties ?? {};
-        const required = new Set(this.schema?.required ?? []);
-        const effective = this.effectiveValue;
-        const out = {};
-        for (const key of Object.keys(props)) {
-            if (!required.has(key))
-                continue;
-            if (isFieldEmpty(props[key], effective[key])) {
-                out[key] = 'This field is required.';
-            }
-        }
-        return out;
-    }
-    /** Non-mutating validity check — unlike `reportValidity()`, never reveals inline errors. */
-    checkValidity() {
-        return this.internals.checkValidity();
-    }
-    /**
-     * Reveals inline errors for every currently-invalid required field (as if
-     * each had been visited) and returns overall validity — the hook a
-     * consumer's own Submit/Approve button should call right before acting,
-     * mirroring a native `<form>`'s `reportValidity()`.
-     */
-    reportValidity() {
-        const errors = this.computeErrors();
-        if (Object.keys(errors).length > 0) {
-            this.touchedFields = new Set([...this.touchedFields, ...Object.keys(errors)]);
-        }
-        return this.internals.checkValidity();
-    }
-    formResetCallback() {
-        this.value = {};
-        this.touchedFields = new Set();
-    }
-    formDisabledCallback(disabled) {
-        this.disabled = disabled;
-    }
-    willUpdate(changed) {
-        if (changed.has('value') || changed.has('schema') || !this.hasUpdated) {
-            this._errors = this.computeErrors();
-        }
-    }
-    /** Pushes `effectiveValue`/`errors` into `ElementInternals` — see the class doc's form-participation note. */
-    syncInternals() {
-        this.internals.setFormValue(JSON.stringify(this.effectiveValue));
-        if (Object.keys(this._errors).length === 0) {
-            this.internals.setValidity({});
-        }
-        else {
-            const firstMessage = Object.values(this._errors)[0] ?? 'Some required fields are empty.';
-            this.internals.setValidity({ valueMissing: true }, firstMessage);
-        }
-    }
-    updated(changed) {
-        if (changed.has('value') || changed.has('schema')) {
-            this.syncInternals();
-            const valid = Object.keys(this._errors).length === 0;
-            const key = JSON.stringify({ valid, errors: this._errors });
-            if (key !== this.lastValidityKey) {
-                this.lastValidityKey = key;
-                this.emit('lyra-validity-change', { valid, errors: { ...this._errors } });
-            }
-        }
-    }
-    setFieldValue(key, val) {
-        this.value = { ...this.value, [key]: val };
-        this.emit('lyra-input', { value: this.effectiveValue });
-    }
-    markTouched(key) {
-        if (this.touchedFields.has(key))
-            return;
-        this.touchedFields = new Set(this.touchedFields).add(key);
-    }
-    onTextInput(key, e) {
-        this.setFieldValue(key, e.target.value);
-    }
-    onNumberInput(key, e) {
-        const raw = e.target;
-        const n = raw.valueAsNumber;
-        this.setFieldValue(key, Number.isNaN(n) ? undefined : n);
-    }
-    onSelectChange(key, e) {
-        this.setFieldValue(key, e.target.value);
-    }
-    onCheckboxChange(key, e) {
-        this.setFieldValue(key, e.detail.checked);
-    }
-    renderControl(key, prop, fieldId, label, required, describedBy, errorMessage, effective) {
-        if (prop.type === 'string' && prop.enum && prop.enum.length > 0) {
-            // <lyra-select>/<lyra-checkbox> don't forward a host-level
-            // aria-describedby to their internal focusable element (neither
-            // reads it — and this component doesn't own either file to add that),
-            // so a plain aria-describedby here would silently do nothing for
-            // assistive tech. Fold the error into aria-label instead, which both
-            // select.ts and checkbox.ts *do* read from the host and thread
-            // through -- the description text still reads fine from its adjacent,
-            // DOM-order-following <p part="description"> even without a formal
-            // aria-describedby association.
-            return html `<lyra-select
-        id=${fieldId}
-        aria-label=${errorMessage ? `${label}. ${errorMessage}` : label}
-        .value=${typeof effective === 'string' ? effective : ''}
-        ?required=${required}
-        ?disabled=${this.disabled}
-        @change=${(e) => this.onSelectChange(key, e)}
-      >
-        ${prop.enum.map((v) => html `<lyra-option value=${v}>${v}</lyra-option>`)}
-      </lyra-select>`;
-        }
-        if (prop.type === 'string') {
-            return html `<input
-        class="control"
-        type="text"
-        id=${fieldId}
-        aria-describedby=${describedBy || nothing}
-        aria-invalid=${errorMessage ? 'true' : nothing}
-        .value=${typeof effective === 'string' ? effective : ''}
-        ?required=${required}
-        ?disabled=${this.disabled}
-        @input=${(e) => this.onTextInput(key, e)}
-      />`;
-        }
-        if (prop.type === 'number' || prop.type === 'integer') {
-            const numValue = typeof effective === 'number' && !Number.isNaN(effective) ? String(effective) : '';
-            return html `<input
-        class="control"
-        type="number"
-        id=${fieldId}
-        step=${prop.type === 'integer' ? '1' : 'any'}
-        aria-describedby=${describedBy || nothing}
-        aria-invalid=${errorMessage ? 'true' : nothing}
-        .value=${numValue}
-        ?required=${required}
-        ?disabled=${this.disabled}
-        @input=${(e) => this.onNumberInput(key, e)}
-      />`;
-        }
-        if (prop.type === 'boolean') {
-            // The label lives inside the slot rather than as a sibling <label> --
-            // that slot *is* lyra-checkbox's documented way to give it an
-            // accessible name (see checkbox.ts's own @slot doc), and unlike
-            // aria-describedby, this genuinely works since it's real slotted
-            // content, not an inert host attribute.
-            return html `<lyra-checkbox
-        id=${fieldId}
-        ?checked=${effective === true}
-        ?required=${required}
-        ?disabled=${this.disabled}
-        @lyra-change=${(e) => this.onCheckboxChange(key, e)}
-      >
-        <span part="label">${label}</span>
-      </lyra-checkbox>`;
-        }
-        // Defensive fallback for a schema property outside this phase's scope
-        // (see the class doc) — render a visible note instead of silently
-        // dropping the field or throwing.
-        return html `<p class="unsupported">Unsupported field type "${prop.type}".</p>`;
-    }
-    renderField(key, prop, index) {
-        const required = (this.schema.required ?? []).includes(key);
-        const label = prop.title ?? key;
-        const fieldId = `${this.baseId}-f${index}`;
-        const descId = prop.description ? `${fieldId}-desc` : '';
-        const errId = this._errors[key] ? `${fieldId}-err` : '';
-        const describedBy = [descId, this.touchedFields.has(key) ? errId : ''].filter(Boolean).join(' ');
-        const hasError = this.touchedFields.has(key) && Boolean(this._errors[key]);
-        const errorMessage = hasError ? this._errors[key] : '';
-        const effective = this.effectiveValue[key];
-        const isBoolean = prop.type === 'boolean';
-        return html `
-      <div part="field" class="field" data-key=${key} data-type=${prop.type} ?data-required=${required}
-        @focusout=${() => this.markTouched(key)}
-      >
-        ${isBoolean
-            ? nothing
-            : html `<label part="label" for=${fieldId}>${label}</label>`}
-        ${this.renderControl(key, prop, fieldId, label, required, describedBy, errorMessage, effective)}
-        ${prop.description
-            ? html `<p part="description" id=${descId}>${prop.description}</p>`
-            : nothing}
-        ${hasError ? html `<p part="error" id=${errId} role="alert">${this._errors[key]}</p>` : nothing}
-      </div>
-    `;
-    }
-    render() {
-        const props = this.schema?.properties ?? {};
-        const keys = Object.keys(props);
-        return html `<div part="base">
-      ${keys.map((key, i) => this.renderField(key, props[key], i))}
-    </div>`;
-    }
-}
-__decorate([
-    property({ attribute: false })
-], LyraToolParamForm.prototype, "schema", void 0);
-__decorate([
-    property({ attribute: false })
-], LyraToolParamForm.prototype, "value", void 0);
-__decorate([
-    property()
-], LyraToolParamForm.prototype, "name", void 0);
-__decorate([
-    property({ type: Boolean, reflect: true })
-], LyraToolParamForm.prototype, "disabled", void 0);
-__decorate([
-    state()
-], LyraToolParamForm.prototype, "_errors", void 0);
-__decorate([
-    state()
-], LyraToolParamForm.prototype, "touchedFields", void 0);
+import "../checkbox/checkbox.js";
+import "../combobox/option.js";
+import "../select/select.js";
 defineElement('tool-param-form', LyraToolParamForm);
+//# sourceMappingURL=tool-param-form.js.map

package/dist/components/tool-param-form/tool-param-form.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-param-form.js","sourceRoot":"","sources":["../../../src/components/tool-param-form/tool-param-form.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,yBAAyB,CAAC;AACjC,OAAO,uBAAuB,CAAC;AAC/B,OAAO,qBAAqB,CAAC;AAC7B,aAAa,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC"}

package/dist/components/tool-param-form/tool-param-form.styles.d.ts

@@ -1 +1,2 @@
 export declare const styles: import("lit").CSSResult;
+//# sourceMappingURL=tool-param-form.styles.d.ts.map

package/dist/components/tool-param-form/tool-param-form.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-param-form.styles.d.ts","sourceRoot":"","sources":["../../../src/components/tool-param-form/tool-param-form.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,yBAyElB,CAAC"}

package/dist/components/tool-param-form/tool-param-form.styles.js

@@ -16,8 +16,8 @@ export const styles = css `
   }
   [part='label'] {
     display: block;
-    font-size: 0.875rem;
-    font-weight: 600;
+    font-size: var(--lyra-font-size-md-sm);
+    font-weight: var(--lyra-font-weight-semibold);
   }
   /* Applies to a boolean field's slotted <span part="label"> (inside
      <lyra-checkbox>) too -- see tool-param-form.ts's class doc for why that
@@ -35,14 +35,14 @@ export const styles = css `
 
   input.control {
     box-sizing: border-box;
-    min-block-size: 2.5rem;
+    min-block-size: var(--lyra-size-2-5rem);
     padding: var(--lyra-space-xs) var(--lyra-space-s);
-    border: 1px solid var(--lyra-color-border);
+    border: var(--lyra-border-width-thin) solid var(--lyra-color-border);
     border-radius: var(--lyra-radius);
     background: var(--lyra-color-surface);
     color: inherit;
     font: inherit;
-    font-size: 1rem;
+    font-size: var(--lyra-font-size-md);
   }
   input.control:focus-visible {
     outline: var(--lyra-focus-ring-width) solid var(--lyra-focus-ring-color);
@@ -58,18 +58,19 @@ export const styles = css `
 
   [part='description'] {
     margin: 0;
-    font-size: 0.8125rem;
+    font-size: var(--lyra-font-size-sm);
     color: var(--lyra-color-text-quiet);
   }
   [part='error'] {
     margin: 0;
-    font-size: 0.8125rem;
+    font-size: var(--lyra-font-size-sm);
     color: var(--lyra-color-danger);
   }
   .unsupported {
     margin: 0;
-    font-size: 0.8125rem;
+    font-size: var(--lyra-font-size-sm);
     font-style: italic;
     color: var(--lyra-color-text-quiet);
   }
 `;
+//# sourceMappingURL=tool-param-form.styles.js.map

package/dist/components/tool-param-form/tool-param-form.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-param-form.styles.js","sourceRoot":"","sources":["../../../src/components/tool-param-form/tool-param-form.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyExB,CAAC"}