@pathscale/ui 2.1.1 → 2.2.0

package/dist/components/combo-box/ComboBox.generated.js

@@ -4,6 +4,7 @@ import "./ComboBox.css";
 import { For, Show, createContext, createEffect, createMemo, createSignal, createUniqueId, onCleanup, onMount, splitProps, useContext } from "solid-js";
 import { twMerge } from "tailwind-merge";
 import { CLASSES, componentRecipe } from "./ComboBox.recipe.js";
+import { resolveState } from "../vocabulary.js";
 var _tmpl$ = /*#__PURE__*/ template("<input type=hidden>"), _tmpl$2 = /*#__PURE__*/ template("<div>"), _tmpl$3 = /*#__PURE__*/ template("<span>"), _tmpl$4 = /*#__PURE__*/ template("<input>"), _tmpl$5 = /*#__PURE__*/ template("<button>"), _tmpl$6 = /*#__PURE__*/ template("<div>No matching options"), _tmpl$7 = /*#__PURE__*/ template("<div role=option tabindex=-1 data-slot=combobox-option><span>"), _tmpl$8 = /*#__PURE__*/ template("<span><span>");
 const ComboBoxContext = createContext();
 const invokeEventHandler = (handler, event)=>{
@@ -45,7 +46,6 @@ const __solidLayoutComboBoxRoot = (_stable, p)=>{
         "startIcon",
         "endIcon",
         "class",
-        "className",
         "dataTheme",
         "style",
         "items",
@@ -55,19 +55,18 @@ const __solidLayoutComboBoxRoot = (_stable, p)=>{
         "inputValue",
         "defaultInputValue",
         "onInputChange",
-        "isOpen",
+        "open",
         "defaultOpen",
         "onOpenChange",
         "fullWidth",
         "variant",
         "menuTrigger",
-        "isDisabled",
+        "state",
         "disabled",
-        "isInvalid",
+        "issues",
         "allowsCustomValue",
         "placeholder",
         "name",
-        "isRequired",
         "required",
         "defaultFilter",
         "itemKey",
@@ -86,10 +85,10 @@ const __solidLayoutComboBoxRoot = (_stable, p)=>{
     const variant = ()=>local.variant ?? "primary";
     const menuTrigger = ()=>local.menuTrigger ?? "focus";
     const fullWidth = ()=>Boolean(local.fullWidth);
-    const isDisabled = ()=>Boolean(local.isDisabled) || Boolean(local.disabled);
-    const isInvalid = ()=>Boolean(local.isInvalid);
-    const isRequired = ()=>Boolean(local.isRequired) || Boolean(local.required);
-    const isOpen = ()=>void 0 !== local.isOpen ? Boolean(local.isOpen) : internalOpen();
+    const isDisabled = ()=>Boolean("disabled" === local.state) || Boolean(local.disabled);
+    const isInvalid = ()=>Boolean("invalid" === resolveState(local.state, local.issues));
+    const isRequired = ()=>Boolean(local.required) || Boolean(local.required);
+    const isOpen = ()=>void 0 !== local.open ? Boolean(local.open) : internalOpen();
     const selectedKey = createMemo(()=>void 0 !== local.selectedKey ? normalizeKey(local.selectedKey) : internalSelectedKey());
     const inputValue = createMemo(()=>void 0 !== local.inputValue ? local.inputValue : internalInputValue());
     const normalizedItems = createMemo(()=>(local.items ?? []).map((item, index)=>{
@@ -124,7 +123,7 @@ const __solidLayoutComboBoxRoot = (_stable, p)=>{
     };
     const setOpen = (next, options)=>{
         if (next && isDisabled()) return;
-        if (void 0 === local.isOpen) setInternalOpen(next);
+        if (void 0 === local.open) setInternalOpen(next);
         local.onOpenChange?.(next);
         if (!next && options?.focusInput) queueMicrotask(()=>{
             inputRef?.focus();
@@ -242,7 +241,7 @@ const __solidLayoutComboBoxRoot = (_stable, p)=>{
                 if ("function" == typeof local.ref) local.ref(node);
             }, _el$);
             spread(_el$, mergeProps(others, ()=>({
-                    class: twMerge(CLASSES.Root.base, CLASSES.Root.variant[variant()], fullWidth() && CLASSES.Root.flag.fullWidth, local.class, local.className)
+                    class: twMerge(CLASSES.Root.base, CLASSES.Root.variant[variant()], fullWidth() && CLASSES.Root.flag.fullWidth, local.class)
                 }), {
                 "data-slot": "combobox",
                 get ["data-open"] () {
@@ -334,14 +333,13 @@ const __solidLayoutComboBoxInputGroup = (_stable, p)=>{
     const [local, others] = splitProps(p, [
         "children",
         "class",
-        "className",
         "dataTheme",
         "style"
     ]);
     return (()=>{
         var _el$4 = _tmpl$2();
         spread(_el$4, mergeProps(others, ()=>({
-                class: twMerge(CLASSES.InputGroup.base, context?.fullWidth() && CLASSES.InputGroup.flag.fullWidth, local.class, local.className)
+                class: twMerge(CLASSES.InputGroup.base, context?.fullWidth() && CLASSES.InputGroup.flag.fullWidth, local.class)
             }), {
             "data-slot": "combobox-input-group",
             get ["data-disabled"] () {
@@ -370,7 +368,6 @@ const __solidLayoutComboBoxInput = (_stable, p)=>{
     const context = useContext(ComboBoxContext);
     const [local, others] = splitProps(p, [
         "class",
-        "className",
         "dataTheme",
         "style",
         "onInput",
@@ -473,7 +470,7 @@ const __solidLayoutComboBoxInput = (_stable, p)=>{
                 return context?.isInvalid() ? "true" : void 0;
             }
         }, ()=>({
-                class: twMerge(CLASSES.Input.base, local.class, local.className)
+                class: twMerge(CLASSES.Input.base, local.class)
             }), {
             "data-slot": "combobox-input",
             get ["data-theme"] () {
@@ -509,7 +506,6 @@ const __solidLayoutComboBoxTrigger = (_stable, p)=>{
     const [local, others] = splitProps(p, [
         "children",
         "class",
-        "className",
         "dataTheme",
         "style",
         "startIcon",
@@ -526,7 +522,7 @@ const __solidLayoutComboBoxTrigger = (_stable, p)=>{
         spread(_el$6, mergeProps(others, {
             type: "button"
         }, ()=>({
-                class: twMerge(CLASSES.Trigger.base, local.class, local.className)
+                class: twMerge(CLASSES.Trigger.base, local.class)
             }), {
             "data-slot": "combobox-trigger",
             get ["data-open"] () {
@@ -594,14 +590,13 @@ const __solidLayoutComboBoxPopover = (_stable, p)=>{
     const [local, others] = splitProps(p, [
         "children",
         "class",
-        "className",
         "dataTheme",
         "style"
     ]);
     return (()=>{
         var _el$9 = _tmpl$2();
         spread(_el$9, mergeProps(others, ()=>({
-                class: twMerge(CLASSES.Popover.base, local.class, local.className)
+                class: twMerge(CLASSES.Popover.base, local.class)
             }), {
             "data-slot": "combobox-popover",
             get ["data-open"] () {
@@ -628,10 +623,9 @@ const __solidLayoutComboBoxList = (_stable, p)=>{
     const [local, others] = splitProps(p, [
         "children",
         "class",
-        "className",
         "dataTheme",
         "style",
-        "renderEmptyState",
+        "renderEmpty",
         "endIcon"
     ]);
     const items = ()=>context?.filteredItems() ?? [];
@@ -643,7 +637,7 @@ const __solidLayoutComboBoxList = (_stable, p)=>{
             },
             role: "listbox"
         }, ()=>({
-                class: twMerge(CLASSES.List.base, local.class, local.className)
+                class: twMerge(CLASSES.List.base, local.class)
             }), {
             "data-slot": "combobox-list",
             get ["data-theme"] () {
@@ -658,7 +652,7 @@ const __solidLayoutComboBoxList = (_stable, p)=>{
                 return items().length > 0;
             },
             get fallback () {
-                return local.renderEmptyState?.() ?? (()=>{
+                return local.renderEmpty?.() ?? (()=>{
                     var _el$1 = _tmpl$6();
                     spread(_el$1, mergeProps(()=>({
                             class: CLASSES.List.empty

package/dist/components/composer/Composer.css

@@ -0,0 +1,109 @@
+@layer components {
+  .composer {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+    width: 100%;
+    padding: 0.5rem;
+    background: var(--color-base-100);
+    border: var(--border, 1px) solid var(--color-base-300);
+  }
+
+  .composer--solid { background: var(--color-base-200); border-color: transparent; }
+  .composer--soft { background: var(--color-base-200); }
+  .composer--outline { background: transparent; }
+  .composer--ghost { background: transparent; border-color: transparent; }
+  .composer--plain { background: none; border: 0; padding: 0; }
+
+  .composer--radius-none { border-radius: 0; }
+  .composer--radius-sm { border-radius: var(--radius-field, 0.25rem); }
+  .composer--radius-md { border-radius: 0.5rem; }
+  .composer--radius-lg { border-radius: 0.75rem; }
+  .composer--radius-full { border-radius: 1.5rem; }
+
+  .composer:focus-within {
+    border-color: var(--color-primary);
+  }
+
+  /* Height is written by autosize, so nothing here may fight it: no `rows`
+     driven min-height, no transition on height. A transition would animate
+     every keystroke that changes a line. */
+  .composer__field {
+    width: 100%;
+    resize: none;
+    overflow-y: auto;
+    border: 0;
+    padding: 0.25rem 0.25rem;
+    background: none;
+    color: inherit;
+    font: inherit;
+    line-height: 22px;
+  }
+
+  .composer__field:focus {
+    outline: none;
+  }
+
+  .composer__toolbar {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  .composer__lead,
+  .composer__trail {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem;
+  }
+
+  /* Pushes the submit button to the end and takes the slack, so a hint that
+     wraps does not move the button. */
+  .composer__hint {
+    flex: 1 1 auto;
+    min-width: 0;
+    color: var(--color-base-content);
+    opacity: 0.6;
+    font-size: 0.8125rem;
+  }
+
+  .composer__submit {
+    flex-shrink: 0;
+    margin-inline-start: auto;
+  }
+
+  .composer__submit:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .composer__issues {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+    font-size: 0.8125rem;
+  }
+
+  .composer__issues [data-severity="error"] { color: var(--color-error); }
+  .composer__issues [data-severity="warning"] { color: var(--color-warning); }
+
+  .composer--xs { font-size: 0.75rem; }
+  .composer--sm { font-size: 0.8125rem; }
+  .composer--md { font-size: 0.875rem; }
+  .composer--lg { font-size: 1rem; }
+  .composer--xl { font-size: 1.125rem; }
+
+  /* Sending keeps the text readable: a greyed-out box during a send reads as
+     "your message was lost" to anyone who looks away and back. */
+  .composer--loading .composer__field { opacity: 0.85; }
+
+  .composer--error,
+  .composer--invalid { border-color: var(--color-error); }
+
+  .composer--disabled {
+    opacity: 0.5;
+    pointer-events: none;
+  }
+
+  .composer--hidden { display: none; }
+}

package/dist/components/composer/Composer.generated.d.ts

@@ -0,0 +1,46 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./Composer.css";
+import { type JSX } from "solid-js";
+import type { ChangeReason, Issue, Radius, Size, State, UIBaseProps, Variant } from "../vocabulary";
+export type ComposerProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange" | "onSubmit" | "children"> & UIBaseProps & {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string, reason?: ChangeReason) => void;
+    /** Fired with the trimmed message. Not fired while `state` is `loading`. */
+    onSubmit?: (value: string) => void;
+    placeholder?: string;
+    size?: Size;
+    variant?: Variant;
+    radius?: Radius;
+    /** `loading` means a send is in flight: the box stays readable and refuses to send again. */
+    state?: State;
+    /** Server-side or asynchronous problems, rendered under the box. */
+    issues?: Issue[];
+    minRows?: number;
+    maxRows?: number;
+    /**
+     * Enter sends. Set false where a newline is the common case and sending is
+     * an explicit act, which is what long-form editors want.
+     */
+    submitOnEnter?: boolean;
+    /**
+     * Announced whenever the box changes height.
+     *
+     * A chat transcript that pins to the bottom has to know: the composer
+     * growing by a line moves the bottom, and a scroller that finds out by
+     * observing the DOM finds out a frame late and jitters.
+     */
+    onHeightChange?: (height: number) => void;
+    /** Controls before the field: attachments, model pickers, mode switches. */
+    lead?: JSX.Element;
+    /** Controls after the field, before the submit button. */
+    trail?: JSX.Element;
+    submitLabel?: JSX.Element;
+    /** Shown beside the controls. Usually the Enter/Shift+Enter reminder. */
+    hint?: JSX.Element;
+    autofocus?: boolean;
+    name?: string;
+    /** Height of the window, for the ceiling. Injected for runtimes without one. */
+    viewportHeight?: number;
+};
+export declare const ComposerLayout: __LayoutComponent<ComposerProps>;

package/dist/components/composer/Composer.generated.js

@@ -0,0 +1,153 @@
+import { createComponent, effect, insert, mergeProps, setAttribute, spread, template, use } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./Composer.css";
+import { For, Show, createEffect, createSignal, onMount } from "solid-js";
+import { isInvalid, resolveState } from "../vocabulary.js";
+import { composer } from "./Composer.recipe.js";
+import { afterValueLands, autosize, boundsFromRows, isSubmittable, newAutosizeMemo, shouldSubmit, viewportHeight } from "./Composer.interactions.js";
+var _tmpl$ = /*#__PURE__*/ template("<span>"), _tmpl$2 = /*#__PURE__*/ template("<ul>"), _tmpl$3 = /*#__PURE__*/ template("<div><textarea></textarea><div><button>"), _tmpl$4 = /*#__PURE__*/ template("<li>");
+const __solidLayoutComposerLayout = (_stable, p)=>{
+    const [internal, setInternal] = createSignal(p.defaultValue ?? "");
+    const value = ()=>p.value ?? internal();
+    const busy = ()=>"loading" === p.state || "disabled" === p.state;
+    const state = ()=>resolveState(p.state, p.issues);
+    let field;
+    const memo = newAutosizeMemo();
+    const measure = ()=>{
+        if (!field) return;
+        const bounds = boundsFromRows(p.minRows ?? 1, p.maxRows ?? 8, viewportHeight(p.viewportHeight));
+        p.onHeightChange?.(autosize(field, bounds, memo));
+    };
+    onMount(()=>{
+        if (p.autofocus) field?.focus();
+        measure();
+    });
+    createEffect(()=>{
+        value();
+        measure();
+    });
+    const write = (next, reason)=>{
+        if (void 0 === p.value) setInternal(next);
+        p.onChange?.(next, reason);
+    };
+    const submit = ()=>{
+        if (busy()) return;
+        const message = value().trim();
+        if (!isSubmittable(message)) return;
+        p.onSubmit?.(message);
+        if (void 0 === p.value) setInternal("");
+    };
+    return (()=>{
+        var _el$ = _tmpl$3(), _el$2 = _el$.firstChild, _el$3 = _el$2.nextSibling, _el$7 = _el$3.firstChild;
+        spread(_el$, mergeProps(()=>_stable.slot.root, {
+            get ["data-state"] () {
+                return state();
+            }
+        }), false, true);
+        var _ref$ = field;
+        "function" == typeof _ref$ ? use(_ref$, _el$2) : field = _el$2;
+        spread(_el$2, mergeProps(()=>_stable.slot.field, {
+            get name () {
+                return p.name;
+            },
+            get value () {
+                return value();
+            },
+            get rows () {
+                return p.minRows ?? 1;
+            },
+            get placeholder () {
+                return p.placeholder;
+            },
+            get disabled () {
+                return "disabled" === p.state;
+            },
+            get ["aria-invalid"] () {
+                return isInvalid(p.issues) ? "true" : void 0;
+            },
+            onInput: (event)=>{
+                write(event.currentTarget.value, "input");
+                measure();
+            },
+            onPaste: ()=>afterValueLands(measure),
+            onKeyDown: (event)=>{
+                if (!shouldSubmit(event, false !== p.submitOnEnter)) return;
+                event.preventDefault();
+                submit();
+            }
+        }), false, false);
+        spread(_el$3, mergeProps(()=>_stable.slot.toolbar), false, true);
+        insert(_el$3, createComponent(Show, {
+            get when () {
+                return p.lead;
+            },
+            get children () {
+                var _el$4 = _tmpl$();
+                spread(_el$4, mergeProps(()=>_stable.slot.lead), false, true);
+                insert(_el$4, ()=>p.lead);
+                return _el$4;
+            }
+        }), _el$7);
+        insert(_el$3, createComponent(Show, {
+            get when () {
+                return p.hint;
+            },
+            get children () {
+                var _el$5 = _tmpl$();
+                spread(_el$5, mergeProps(()=>_stable.slot.hint), false, true);
+                insert(_el$5, ()=>p.hint);
+                return _el$5;
+            }
+        }), _el$7);
+        insert(_el$3, createComponent(Show, {
+            get when () {
+                return p.trail;
+            },
+            get children () {
+                var _el$6 = _tmpl$();
+                spread(_el$6, mergeProps(()=>_stable.slot.trail), false, true);
+                insert(_el$6, ()=>p.trail);
+                return _el$6;
+            }
+        }), _el$7);
+        spread(_el$7, mergeProps(()=>_stable.slot.submit, {
+            type: "button",
+            onClick: submit,
+            get disabled () {
+                return busy() || !isSubmittable(value());
+            },
+            get ["data-loading"] () {
+                return "loading" === p.state ? "true" : "false";
+            }
+        }), false, true);
+        insert(_el$7, ()=>p.submitLabel ?? "Send");
+        insert(_el$, createComponent(Show, {
+            get when () {
+                return p.issues?.length;
+            },
+            get children () {
+                var _el$8 = _tmpl$2();
+                spread(_el$8, mergeProps(()=>_stable.slot.issues), false, true);
+                insert(_el$8, createComponent(For, {
+                    get each () {
+                        return p.issues;
+                    },
+                    children: (issue)=>(()=>{
+                            var _el$9 = _tmpl$4();
+                            insert(_el$9, ()=>issue.message ?? issue.code);
+                            effect(()=>setAttribute(_el$9, "data-severity", issue.severity ?? "error"));
+                            return _el$9;
+                        })()
+                }));
+                return _el$8;
+            }
+        }), null);
+        return _el$;
+    })();
+};
+const ComposerLayout = defineComponent({
+    recipe: composer,
+    layout: __solidLayoutComposerLayout,
+    embedded: true
+});
+export { ComposerLayout };

package/dist/components/composer/Composer.interactions.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Pure mechanics behind `Composer`.
+ *
+ * They live apart from the Layout because a `.layout.tsx` template resolves
+ * free identifiers against props, so a bare `setTimeout` or `window` in that
+ * file compiles to `props.setTimeout`. They are also the part worth testing
+ * directly: autosize is where a chat box gets slow, and submit resolution is
+ * where it gets rude.
+ */
+/** A textarea, reduced to what autosize actually touches. */
+export type AutosizeField = {
+    value: string;
+    scrollHeight: number;
+    style: {
+        height: string;
+        maxHeight: string;
+    };
+};
+export type AutosizeBounds = {
+    /** Smallest height to hold, in pixels. Keeps one writable line while layout settles. */
+    floor: number;
+    /** Largest height before the field scrolls instead of growing. */
+    ceiling: number;
+};
+/**
+ * State carried between measurements.
+ *
+ * Not decoration: without it every keystroke writes a style, and a style write
+ * marks layout stale, so the `scrollHeight` read that follows has to resolve
+ * the whole document before it can answer. Measured at 12.77ms per keystroke on
+ * a 3,599-node tree, which was 82 percent of the cost of typing a character.
+ */
+export type AutosizeMemo = {
+    length: number;
+    height: number;
+    ceiling: number;
+};
+export declare const newAutosizeMemo: () => AutosizeMemo;
+/**
+ * Grow with the content up to a ceiling, then scroll.
+ *
+ * Returns the height applied, so a caller can tell a surrounding scroller what
+ * changed. Writes nothing when nothing moved, which is most keystrokes: text
+ * usually lands inside the current line.
+ *
+ * The `height = "auto"` reset is what lets the field *shrink* — with a fixed
+ * height larger than its content, `scrollHeight` reports the box rather than
+ * the text. It is also a style write, so it is skipped while the content is
+ * only getting longer, where the box is never taller than the text and the
+ * reset buys nothing.
+ */
+export declare const autosize: (field: AutosizeField, bounds: AutosizeBounds, memo: AutosizeMemo) => number;
+/** Pixels per row, used only to turn a row count into a bound. */
+export declare const ROW_HEIGHT = 22;
+/**
+ * Turn rows into pixel bounds, never letting the box eat the window.
+ *
+ * `viewportHeight` is passed in rather than read, so this stays pure and so a
+ * runtime without a window can still call it.
+ */
+export declare const boundsFromRows: (minRows: number, maxRows: number, viewportHeight: number, fraction?: number) => AutosizeBounds;
+export type SubmitKey = {
+    key: string;
+    shiftKey: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    isComposing?: boolean;
+};
+/**
+ * Does this keystroke send?
+ *
+ * Enter sends and Shift+Enter is a newline, which is what a chat box has
+ * trained everyone to expect. `isComposing` is the part that is easy to miss:
+ * while an IME is open, Enter commits the candidate and must not also send the
+ * message. Skipping that check sends half a word in Japanese, Chinese and
+ * Korean and looks like the app is broken to everyone who uses one.
+ */
+export declare const shouldSubmit: (event: SubmitKey, submitOnEnter: boolean) => boolean;
+/** Nothing but whitespace is not a message, so it never submits. */
+export declare const isSubmittable: (value: string) => boolean;
+/**
+ * Run after the pending value has landed in the field.
+ *
+ * A paste changes the value through the browser rather than through us, so
+ * measuring in the handler measures the box as it was. The deferral lives here
+ * because a bare `queueMicrotask` inside a `.layout.tsx` compiles to
+ * `props.queueMicrotask`: free identifiers in a template bind to props, and
+ * timers are not on the known-globals list.
+ */
+export declare const afterValueLands: (measure: () => void) => void;
+/** The window height, or a sane stand-in where there is no window. */
+export declare const viewportHeight: (override?: number) => number;

package/dist/components/composer/Composer.interactions.js

@@ -0,0 +1,42 @@
+const newAutosizeMemo = ()=>({
+        length: -1,
+        height: -1,
+        ceiling: -1
+    });
+const autosize = (field, bounds, memo)=>{
+    if (bounds.ceiling !== memo.ceiling) {
+        field.style.maxHeight = `${bounds.ceiling}px`;
+        memo.ceiling = bounds.ceiling;
+        memo.length = -1;
+    }
+    const length = field.value.length;
+    if (length < memo.length || memo.length < 0) field.style.height = "auto";
+    memo.length = length;
+    const height = Math.max(bounds.floor, Math.min(field.scrollHeight || bounds.floor, bounds.ceiling));
+    if (height !== memo.height) {
+        field.style.height = `${height}px`;
+        memo.height = height;
+    }
+    return height;
+};
+const ROW_HEIGHT = 22;
+const boundsFromRows = (minRows, maxRows, viewportHeight, fraction = 0.45)=>{
+    const floor = Math.max(1, minRows) * ROW_HEIGHT;
+    const viewportCeiling = Math.max(floor, Math.floor(viewportHeight * fraction));
+    return {
+        floor,
+        ceiling: Math.min(Math.max(1, maxRows) * ROW_HEIGHT, viewportCeiling)
+    };
+};
+const shouldSubmit = (event, submitOnEnter)=>{
+    if (!submitOnEnter) return false;
+    if ("Enter" !== event.key) return false;
+    if (event.isComposing) return false;
+    return !event.shiftKey && !event.ctrlKey && !event.metaKey && !event.altKey;
+};
+const isSubmittable = (value)=>value.trim().length > 0;
+const afterValueLands = (measure)=>{
+    queueMicrotask(measure);
+};
+const Composer_interactions_viewportHeight = (override)=>override ?? globalThis.innerHeight ?? 800;
+export { Composer_interactions_viewportHeight as viewportHeight, ROW_HEIGHT, afterValueLands, autosize, boundsFromRows, isSubmittable, newAutosizeMemo, shouldSubmit };