@wssto2/vue-core 0.9.4 → 0.10.0

package/dist/collection/index.js

@@ -1,125 +1,184 @@
-import { D as q, d as z } from "../definition-C7QuyV3i.js";
-import { _ as j, a as G, u as U } from "../CollectionPage.vue_vue_type_script_setup_true_lang-DHcekGNn.js";
-import { h as X, l as Z, r as H } from "../http-nz92KjdS.js";
-import { L as Q } from "../state-6KSYsVw0.js";
-import { u as Y, a as ee } from "../neighbors-DVfU9T0o.js";
-import { r as f } from "../route-goWMxDUN.js";
-import { b as se, a as ae } from "../rowLayout-CT8vWYgI.js";
-import { _ as ne } from "../DataTable.vue_vue_type_script_setup_true_lang-8kBsNRuq.js";
-import { defineComponent as k, openBlock as d, createElementBlock as c, Fragment as C, renderList as g, createBlock as h, unref as m, withCtx as E, normalizeClass as p, createVNode as b, createCommentVNode as S } from "vue";
-import { _ } from "../Icon.vue_vue_type_script_lang-BhhsFYwp.js";
-import { _ as T } from "../Tooltip.vue_vue_type_script_setup_true_lang-Dtg5Y6pf.js";
-import { D as ie, u as le } from "../datePresets-DB13HHHd.js";
-const v = {
-  index: f("GET", "/v1/saved-views"),
-  store: f("POST", "/v1/saved-views"),
-  delete: f("DELETE", "/v1/saved-views/:id")
-}, x = ({ id: o, name: t, state: a }) => ({ id: o, name: t, state: a });
-function I(o) {
+import { D as K, d as Q, h as W, l as Y, r as ee } from "../http-Dm0uXY9O.js";
+import { _ as se, a as oe, u as ie } from "../CollectionPage.vue_vue_type_script_setup_true_lang-Cn0YOWJF.js";
+import { L as ne } from "../state-6KSYsVw0.js";
+import { a as re, u as ce } from "../neighbors-OyvGi233.js";
+import { r as p } from "../route-goWMxDUN.js";
+import { b as ue, a as fe } from "../rowLayout-Il4psyXN.js";
+import { _ as me } from "../DataTable.vue_vue_type_script_setup_true_lang-BQRG8bpH.js";
+import { defineComponent as w, openBlock as c, createElementBlock as u, Fragment as P, renderList as E, createBlock as h, unref as d, withCtx as y, normalizeClass as v, createVNode as _, createCommentVNode as g, shallowRef as S, useTemplateRef as T, watch as D, renderSlot as R } from "vue";
+import { _ as b } from "../Icon.vue_vue_type_script_lang-BhhsFYwp.js";
+import { _ as z } from "../Tooltip.vue_vue_type_script_setup_true_lang-Dtg5Y6pf.js";
+import { D as _e, u as be } from "../datePresets-DB13HHHd.js";
+import { h as xe } from "../highlight-DnYhLXnu.js";
+import { useI18n as A } from "vue-i18n";
+import { _ as L } from "../Modal.vue_vue_type_script_setup_true_lang-DDS0iEnn.js";
+const m = {
+  index: p("GET", "/v1/saved-views"),
+  store: p("POST", "/v1/saved-views"),
+  delete: p("DELETE", "/v1/saved-views/:id")
+}, k = ({ id: a, name: e, state: i }) => ({ id: a, name: e, state: i });
+function j(a) {
   return {
-    async list(t, { signal: a }) {
-      return (await o.request(v.index, { list: t }, { signal: a })).data.map(x);
+    async list(e, { signal: i }) {
+      return (await a.request(m.index, { list: e }, { signal: i })).data.map(k);
     },
-    async save(t, a, n) {
-      const s = JSON.stringify({ ...n, view: n.view || void 0 });
-      return x((await o.request(v.store, { list_key: t, name: a, state: s })).data);
+    async save(e, i, o) {
+      const s = JSON.stringify({ ...o, view: o.view || void 0 });
+      return k((await a.request(m.store, { list_key: e, name: i, state: s })).data);
     },
-    async remove(t, a) {
-      await o.request(v.delete, { id: Number(a) });
+    async remove(e, i) {
+      await a.request(m.delete, { id: Number(i) });
     }
   };
 }
-function O(o = {}) {
-  const t = new Map(Object.entries(o).map(([s, e]) => [s, [...e]]));
-  let a = 1;
-  const n = (s) => {
-    let e = t.get(s);
-    return e || t.set(s, e = []), e;
+function G(a = {}) {
+  const e = new Map(Object.entries(a).map(([s, t]) => [s, [...t]]));
+  let i = 1;
+  const o = (s) => {
+    let t = e.get(s);
+    return t || e.set(s, t = []), t;
   };
   return {
     async list(s) {
-      return [...n(s)];
+      return [...o(s)];
     },
-    async save(s, e, l) {
-      const r = n(s), i = r.findIndex((y) => y.name === e), u = { id: i === -1 ? `view-${a++}` : r[i].id, name: e, state: l };
-      return i === -1 ? r.push(u) : r[i] = u, u;
+    async save(s, t, l) {
+      const n = o(s), r = n.findIndex((C) => C.name === t), f = { id: r === -1 ? `view-${i++}` : n[r].id, name: t, state: l };
+      return r === -1 ? n.push(f) : n[r] = f, f;
     },
-    async remove(s, e) {
-      const l = n(s), r = l.findIndex((i) => i.id === e);
-      r !== -1 && l.splice(r, 1);
+    async remove(s, t) {
+      const l = o(s), n = l.findIndex((r) => r.id === t);
+      n !== -1 && l.splice(n, 1);
     }
   };
 }
-const P = {
+const $ = {
   key: 0,
   class: "flex items-center justify-center gap-1",
   "data-test": "row-actions"
-}, A = ["href", "target", "rel", "aria-label", "data-action"], D = ["aria-label", "data-action", "disabled", "onClick"], w = "focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-border-focus", V = /* @__PURE__ */ k({
+}, I = ["href", "target", "rel", "aria-label", "data-action"], N = ["aria-label", "data-action", "disabled", "onClick"], x = "focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-border-focus", U = /* @__PURE__ */ w({
   __name: "RowActions",
   props: {
     actions: {},
     disabled: { type: Boolean, default: !1 }
   },
-  setup(o) {
-    const t = o, a = (n) => n.tone === "critical" ? "text-status-danger-content hover:bg-status-danger-surface" : "text-content-link hover:bg-tint-soft";
-    return (n, s) => t.actions.length > 0 ? (d(), c("div", P, [
-      (d(!0), c(C, null, g(t.actions, (e) => (d(), h(m(T), {
-        key: e.key,
-        text: e.label,
+  setup(a) {
+    const e = a, i = (o) => o.tone === "critical" ? "text-status-danger-content hover:bg-status-danger-surface" : "text-content-link hover:bg-tint-soft";
+    return (o, s) => e.actions.length > 0 ? (c(), u("div", $, [
+      (c(!0), u(P, null, E(e.actions, (t) => (c(), h(d(z), {
+        key: t.key,
+        text: t.label,
         side: "left"
       }, {
-        default: E(() => [
-          e.href && !t.disabled ? (d(), c("a", {
+        default: y(() => [
+          t.href && !e.disabled ? (c(), u("a", {
             key: 0,
-            href: e.href,
-            target: e.external ? "_blank" : void 0,
-            rel: e.external ? "noopener" : void 0,
-            "aria-label": e.label,
-            "data-action": e.key,
-            class: p(["inline-flex rounded-md p-1.5 transition-colors", [a(e), w]])
+            href: t.href,
+            target: t.external ? "_blank" : void 0,
+            rel: t.external ? "noopener" : void 0,
+            "aria-label": t.label,
+            "data-action": t.key,
+            class: v(["inline-flex rounded-md p-1.5 transition-colors", [i(t), x]])
           }, [
-            b(m(_), {
-              name: e.icon,
+            _(d(b), {
+              name: t.icon,
               size: 18
             }, null, 8, ["name"])
-          ], 10, A)) : (d(), c("button", {
+          ], 10, I)) : (c(), u("button", {
             key: 1,
             type: "button",
-            "aria-label": e.label,
-            "data-action": e.key,
-            disabled: t.disabled,
-            class: p(["inline-flex cursor-pointer rounded-md p-1.5 transition-colors disabled:pointer-events-none disabled:opacity-40", [a(e), w]]),
-            onClick: (l) => e.onSelect?.()
+            "aria-label": t.label,
+            "data-action": t.key,
+            disabled: e.disabled,
+            class: v(["inline-flex cursor-pointer rounded-md p-1.5 transition-colors disabled:pointer-events-none disabled:opacity-40", [i(t), x]]),
+            onClick: (l) => t.onSelect?.()
           }, [
-            b(m(_), {
-              name: e.icon,
+            _(d(b), {
+              name: t.icon,
               size: 18
             }, null, 8, ["name"])
-          ], 10, D))
+          ], 10, N))
         ]),
         _: 2
       }, 1032, ["text"]))), 128))
-    ])) : S("", !0);
+    ])) : g("", !0);
+  }
+});
+function J() {
+  const a = S({ open: !1, options: null });
+  let e = null;
+  function i(o) {
+    const s = e;
+    e = null, a.value = { open: !1, options: a.value.options }, s?.(o);
+  }
+  return {
+    state: a,
+    pick(...[o]) {
+      return e?.(null), new Promise((s) => {
+        e = s, a.value = { open: !0, options: o ?? {} };
+      });
+    },
+    select: (o) => i(o),
+    cancel: () => i(null)
+  };
+}
+const X = /* @__PURE__ */ w({
+  __name: "PickerModal",
+  props: {
+    picker: {},
+    title: { default: void 0 },
+    description: { default: void 0 },
+    size: { default: "lg" }
+  },
+  setup(a) {
+    const e = a, { t: i } = A(), o = T("modal");
+    let s = !1, t = !1;
+    D(() => e.picker.state.value.open, (n) => {
+      n ? (s = !0, o.value?.present()) : s && (t = !0, o.value?.dismiss());
+    }, { flush: "post" });
+    function l() {
+      s = !1, t ? t = !1 : e.picker.cancel();
+    }
+    return (n, r) => (c(), h(d(L), {
+      ref_key: "modal",
+      ref: o,
+      title: e.picker.state.value.options?.title ?? e.title ?? d(i)("core.collection.pick_label"),
+      subtitle: e.picker.state.value.options?.description ?? e.description,
+      size: e.size,
+      grouped: "",
+      onDismissed: l
+    }, {
+      default: y(() => [
+        e.picker.state.value.options ? R(n.$slots, "default", {
+          options: e.picker.state.value.options,
+          select: e.picker.select
+        }, void 0, void 0, 0) : g("", !0)
+      ]),
+      _: 3
+    }, 8, ["title", "subtitle", "size"]));
   }
 });
 export {
-  se as CollectionCell,
-  j as CollectionPage,
-  G as CollectionTable,
-  ie as DATE_PRESETS,
-  q as DEFAULT_PAGE_SIZES,
-  ne as DataTable,
-  Q as LIST_CONTEXT_PARAM,
-  ae as RecordIdentity,
-  V as RowActions,
-  O as createMemorySavedViews,
-  z as defineCollection,
-  X as httpList,
-  Z as listParams,
-  H as readListPage,
-  I as serverSavedViews,
-  U as useCollection,
-  Y as useCollectionBack,
-  ee as useCollectionNeighbors,
-  le as useDatePresetFilter
+  ue as CollectionCell,
+  se as CollectionPage,
+  oe as CollectionTable,
+  _e as DATE_PRESETS,
+  K as DEFAULT_PAGE_SIZES,
+  me as DataTable,
+  ne as LIST_CONTEXT_PARAM,
+  X as PickerModal,
+  fe as RecordIdentity,
+  U as RowActions,
+  G as createMemorySavedViews,
+  J as createPicker,
+  Q as defineCollection,
+  xe as highlightParts,
+  W as httpList,
+  Y as listParams,
+  ee as readListPage,
+  j as serverSavedViews,
+  ie as useCollection,
+  re as useCollectionBack,
+  ce as useCollectionNeighbors,
+  be as useDatePresetFilter
 };

package/dist/collection/picker.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from "vue";
+/** What every picker takes; add the fields your list needs (a record to exclude, a scope). */
+export interface PickerOptions {
+    /** Overrides the dialog's title for this call. */
+    title?: string;
+    /** A second line under the title for this call. */
+    description?: string;
+}
+/** The arguments of `pick`: optional when every option is. */
+type PickArguments<Options> = Partial<Options> extends Options ? [options?: Options] : [options: Options];
+export interface Picker<Row, Options extends PickerOptions = PickerOptions> {
+    /** Whether the dialog is open and what it was opened with; read by `PickerModal`. */
+    readonly state: Readonly<Ref<{
+        readonly open: boolean;
+        readonly options: Options | null;
+    }>>;
+    /**
+     * Opens the dialog and resolves with the chosen row, or null when it is dismissed. Picking again
+     * while it is open resolves the earlier call with null.
+     */
+    pick(...options: PickArguments<Options>): Promise<Row | null>;
+    /** The choice: resolves `pick` with the row and closes the dialog. */
+    select(row: Row): void;
+    /** Resolves `pick` with null and closes the dialog. */
+    cancel(): void;
+}
+/**
+ * The open, choose and cancel plumbing of a "choose one record" dialog that any screen can ask for
+ * and `await`. One picker per kind of record, made once by the app; `PickerModal` is its dialog:
+ *
+ *   export const userPicker = createPicker<User, { title?: string; locationId?: number }>();
+ *
+ *   const user = await userPicker.pick({ locationId: 4 });   // User, or null when dismissed
+ *
+ * Mount `<PickerModal :picker="userPicker">` once where the app keeps its dialogs (a shell `host`
+ * contribution) and put a `CollectionTable` with `pick` inside it.
+ */
+export declare function createPicker<Row, Options extends PickerOptions = PickerOptions>(): Picker<Row, Options>;
+export {};

package/dist/collection/types.d.ts

@@ -16,8 +16,13 @@ export interface CollectionQuery<Sort extends string = string, Filter extends st
     /** Filter values are what the URL and the backend carry: text. Empty filters are absent. */
     readonly filters: Readonly<Partial<Record<Filter, string>>>;
 }
-/** One page of a list, normalized: what `load` returns, whatever envelope the backend used. */
-export interface ListPage<Row> {
+/** What the backend adds next to a list's rows, untouched: any object until the app says what it sends (`ListPage<Row, MyMeta>`). */
+export type ListMeta = Readonly<Record<string, unknown>>;
+/**
+ * One page of a list, normalized: what `load` returns, whatever envelope the backend used. `Meta` is the shape of `meta`
+ * for a list whose backend sends one, so the app reads it without a cast (declare it as a `type`, not an `interface`, which has no index signature).
+ */
+export interface ListPage<Row, Meta extends ListMeta = ListMeta> {
     readonly rows: readonly Row[];
     /** Rows in the whole result set. */
     readonly total: number;
@@ -34,7 +39,7 @@ export interface ListPage<Row> {
         readonly count?: number;
     }[];
     /** Enrichment the backend adds next to the rows (authors, lookups), untouched. */
-    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly meta?: Meta;
     /** The `X-Request-ID` of the exchange, to quote in a bug report. */
     readonly requestId?: string | null;
 }
@@ -43,7 +48,7 @@ export interface LoadContext {
     readonly signal: AbortSignal;
 }
 /** The typed call a collection makes: the feature's API function. It never builds URLs in a view. */
-export type CollectionLoader<Row, Sort extends string, Filter extends string, View extends string> = (query: CollectionQuery<Sort, Filter, View>, context: LoadContext) => Promise<ListPage<Row>>;
+export type CollectionLoader<Row, Sort extends string, Filter extends string, View extends string, Meta extends ListMeta = ListMeta> = (query: CollectionQuery<Sort, Filter, View>, context: LoadContext) => Promise<ListPage<Row, Meta>>;
 /** Where a list keeps its state between visits. */
 export type CollectionStateSource = 
 /** In the URL's query under `key`: survives reloads and back/forward, and record links carry it (`?from=`). */

package/dist/collection/useCollection.d.ts

@@ -5,7 +5,7 @@ import type { Column } from "./columns";
 import { type CollectionDefinition } from "./definition";
 import { type FilterDescriptor, type ViewDescriptor } from "./filters";
 import type { SavedView, SavedViewState, SavedViews } from "./savedViews";
-import type { ListPage, CollectionQuery, CollectionStateSource, SortDirection } from "./types";
+import type { ListMeta, ListPage, CollectionQuery, CollectionStateSource, SortDirection } from "./types";
 /**
  * A link into a list carries plain parameters (`?scope=long`, `?followup=overdue`): a count on the
  * home page that opens its list filtered the same way. They are applied once when the list is created
@@ -82,7 +82,7 @@ export interface SavedViewsHandle {
  * batch into one request (several calls in a tick load once), a newer request supersedes the older,
  * and a failure is never confused with an empty list.
  */
-export interface Collection<Row, Sort extends string = string, Filter extends string = string, View extends string = string, Col extends Column<Row> = Column<Row>> {
+export interface Collection<Row, Sort extends string = string, Filter extends string = string, View extends string = string, Col extends Column<Row> = Column<Row>, Meta extends ListMeta = ListMeta> {
     /** The definition's id. */
     readonly id: string;
     /** The record's identity (the definition's `key`): what rows are keyed by. */
@@ -92,11 +92,11 @@ export interface Collection<Row, Sort extends string = string, Filter extends st
     /** Whether the list can be searched by text (the definition's `query.search`); the toolbar shows the search field only then. */
     readonly searchable: boolean;
     /** The request state: loading (nothing to show), loaded, refreshing (previous rows stay), stale (a refresh failed, previous rows stay) or failed. */
-    readonly state: Readonly<Ref<AsyncState<ListPage<Row>>>>;
+    readonly state: Readonly<Ref<AsyncState<ListPage<Row, Meta>>>>;
     /** The query the list shows or is loading. */
     readonly query: Readonly<Ref<CollectionQuery<Sort, Filter, View>>>;
     /** The last page that loaded, kept while another loads, refreshes or fails (so the pager and the count stay); null before the first and after a session change. */
-    readonly page: ComputedRef<ListPage<Row> | null>;
+    readonly page: ComputedRef<ListPage<Row, Meta> | null>;
     readonly rows: ComputedRef<readonly Row[]>;
     readonly total: ComputedRef<number>;
     readonly display: ComputedRef<CollectionDisplay>;
@@ -151,4 +151,4 @@ export interface Collection<Row, Sort extends string = string, Filter extends st
  * request only, treats a cancelled request as nothing happened, and follows the URL when the
  * user goes back or forward. It stops with the scope it was created in.
  */
-export declare function useCollection<Row, Sort extends string, Filter extends string, View extends string, const Col extends Column<Row> = Column<Row>>(definition: CollectionDefinition<Row, Sort, Filter, View>, options: UseCollectionOptions<Row, Filter, View, Col, Sort>): Collection<Row, Sort, Filter, View, Col>;
+export declare function useCollection<Row, Sort extends string, Filter extends string, View extends string, const Col extends Column<Row> = Column<Row>, Meta extends ListMeta = ListMeta>(definition: CollectionDefinition<Row, Sort, Filter, View, Meta>, options: UseCollectionOptions<Row, Filter, View, Col, Sort>): Collection<Row, Sort, Filter, View, Col, Meta>;

package/dist/content/ActivityStream.vue.d.ts

@@ -0,0 +1,62 @@
+import type { IconName } from "../icon";
+import type { Tone } from "../state";
+/** Something that happened to the record: an assignment, a phase change. */
+export interface ActivityEvent {
+    kind: "event";
+    id: string | number;
+    at: string | null;
+    icon: IconName;
+    tone?: Tone;
+    /** Who did it (shown in the meta line). */
+    actor?: string | null;
+    /** Plain text; use the `#event` slot for badges or details. */
+    text?: string;
+}
+/** A comment someone wrote. `mine` puts it on the trailing side. */
+export interface ActivityComment {
+    kind: "comment";
+    id: string | number;
+    at: string | null;
+    body: string;
+    author?: string | null;
+    /** The photo's full URL, built by the app; initials show until it loads or without it. */
+    avatarUrl?: string | null;
+    mine?: boolean;
+}
+export type ActivityItem = ActivityEvent | ActivityComment;
+declare const _default: <T extends ActivityItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        items: T[];
+        /** Label of the list for assistive technology. */
+        label?: string;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /** Event content (defaults to `item.text`). */
+        event?: (props: {
+            item: Extract<T, {
+                kind: "event";
+            }>;
+        }) => unknown;
+        /** Extra context in a comment's meta line (the phase it was written in). */
+        "comment-meta"?: (props: {
+            item: Extract<T, {
+                kind: "comment";
+            }>;
+        }) => unknown;
+        /** Extra controls in a comment's meta line (delete). */
+        "comment-actions"?: (props: {
+            item: Extract<T, {
+                kind: "comment";
+            }>;
+        }) => unknown;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/content/CommentThread.vue.d.ts

@@ -0,0 +1,52 @@
+export interface CommentItem {
+    id: number | string;
+    body: string;
+    author?: string;
+    /** The photo's full URL, built by the app. */
+    avatarUrl?: string | null;
+    createdAt?: string | null;
+    /** Written by the signed-in user: shown on the trailing side. */
+    mine?: boolean;
+}
+declare const _default: import("vue").DefineComponent<{
+    comments: CommentItem[];
+    /** Shows the compose box. */
+    canAdd?: boolean;
+    /** Shows each comment's delete control. */
+    canRemove?: boolean;
+    /** Greys out compose and delete while the record cannot change. */
+    disabled?: boolean;
+    title?: string;
+    /** Leave the heading out when the container already names the thread (a sheet titled "Notes"). */
+    hideTitle?: boolean;
+    maxLength?: number;
+    /** Saves a new comment with the trimmed text. */
+    onAdd?: (text: string) => unknown;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    remove: (comment: CommentItem) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    comments: CommentItem[];
+    /** Shows the compose box. */
+    canAdd?: boolean;
+    /** Shows each comment's delete control. */
+    canRemove?: boolean;
+    /** Greys out compose and delete while the record cannot change. */
+    disabled?: boolean;
+    title?: string;
+    /** Leave the heading out when the container already names the thread (a sheet titled "Notes"). */
+    hideTitle?: boolean;
+    maxLength?: number;
+    /** Saves a new comment with the trimmed text. */
+    onAdd?: (text: string) => unknown;
+}> & Readonly<{
+    onRemove?: ((comment: CommentItem) => any) | undefined;
+}>, {
+    disabled: boolean;
+    title: string;
+    maxLength: number;
+    canAdd: boolean;
+    canRemove: boolean;
+    hideTitle: boolean;
+    onAdd: (text: string) => unknown;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/content/Composer.vue.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The message field under an activity stream: a capsule text area that grows with its text and a
+ * round send button that turns tinted once there is something to send.
+ *
+ *   <Composer v-model="draft" :processing="posting" @submit="post" />
+ *
+ * Enter adds a line (comments are prose); Ctrl or ⌘ + Enter sends. `submit` carries the trimmed
+ * text; the owner clears the draft once it is saved, so a failed request keeps what was typed.
+ */
+type __VLS_Props = {
+    placeholder?: string;
+    /** Accessible name of the field; defaults to the placeholder. */
+    label?: string;
+    maxLength?: number;
+    disabled?: boolean;
+    processing?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submit: (text: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSubmit?: ((text: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    label: string;
+    processing: boolean;
+    maxLength: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/content/index.d.ts

@@ -1,4 +1,7 @@
+export { default as ActivityStream, type ActivityComment, type ActivityEvent, type ActivityItem } from "./ActivityStream.vue";
 export { default as Avatar } from "./Avatar.vue";
+export { default as CommentThread, type CommentItem } from "./CommentThread.vue";
+export { default as Composer } from "./Composer.vue";
 export { default as Divider } from "./Divider.vue";
 export { initialsFor } from "./initials";
 export { default as KeyValue } from "./KeyValue.vue";