@dropby/vue 0.4.0

package/dist/components/index.d.ts

@@ -0,0 +1,402 @@
+import { t as PublicComponent } from "../chunks/public-component-A2rcQYAZ.js";
+import { n as ChatAttachmentsToolkit, t as ChatAttachmentDraft } from "../chunks/chat-attachment-types-BG8VFQj5.js";
+import { ExtractPublicPropTypes, MaybeRefOrGetter, PropType, VNode } from "vue";
+import { AskField, AsksActions, AsyncResource, ChatActions, ChatHistoryLoadState, ChatThread as ChatThread$1, ChatThreadActions, ChatThreadsCollection, DropByError, DropById, FlagValue, Idea as Idea$1, IdeasActions, ListIdeasView, PagedCollection, PendingAsk, PendingAsksCollection } from "@dropby/browser";
+declare const askProps: {
+  /** The ask to show. */
+  readonly ask: {
+    readonly type: PropType<PendingAsk>;
+    readonly required: true;
+  };
+  /** Passed to its `AskForm`. */
+  readonly fieldsPerStep: {
+    readonly type: NumberConstructor;
+    readonly default: undefined;
+  };
+};
+/** Props for `Ask`; other attributes go to its `div`. */
+type AskProps = ExtractPublicPropTypes<typeof askProps>;
+/** Slots of `Ask`. */
+interface AskSlots {
+  /** Your own body, given the ask, in place of its title and form. */
+  default?: (state: {
+    ask: PendingAsk;
+  }) => VNode[];
+}
+/**
+ * One pending ask: its title and its `AskForm`, marked `data-pending`.
+ */
+export declare const Ask: PublicComponent<AskProps, AskSlots>;
+/** One field's answer: text, the chosen option ids, or a rating. */
+type AskAnswerValue = string | string[] | number;
+/** The answers given so far, by field id. */
+type AskAnswers = Record<string, AskAnswerValue>;
+/** What the `AskForm` default slot receives. */
+interface AskFormState {
+  /** The ask being answered. */
+  ask: PendingAsk;
+  /** The fields on the current step. */
+  fields: AskField[];
+  /** The answers given so far. */
+  answers: AskAnswers;
+  /** Sets one field's answer, and clears its issue. */
+  setAnswer: (fieldId: string, value: AskAnswerValue) => void;
+  /** The current step, from 0. */
+  step: number;
+  /** How many steps there are. */
+  stepCount: number;
+  /** Whether this is the first step. */
+  isFirst: boolean;
+  /** Whether this is the last step. */
+  isLast: boolean;
+  /** Goes to the step before. */
+  back: () => void;
+  /** Goes to the next step when this one's answers are valid, or shows their issues. */
+  next: () => void;
+  /** Sends every answer when all are valid, or goes to the first step with an issue. */
+  submit: () => Promise<void>;
+  /** Dismisses the ask. */
+  dismiss: () => Promise<void>;
+  /** Whether a submit or dismissal is in flight. */
+  submitting: boolean;
+  /** Each field's issue, in copy for the user, by field id. */
+  issues: Record<string, string>;
+  /** Why the last submit or dismissal failed. */
+  error: DropByError | null;
+}
+declare const askFormProps: {
+  /** The ask to answer. */
+  readonly ask: {
+    readonly type: PropType<PendingAsk>;
+    readonly required: true;
+  };
+  /** How many fields a step shows: all by default, 1 for one at a time. */
+  readonly fieldsPerStep: {
+    readonly type: NumberConstructor;
+    readonly default: undefined;
+  };
+};
+/** Props for `AskForm`; other attributes go to its `form`. */
+type AskFormProps = ExtractPublicPropTypes<typeof askFormProps>;
+/** Slots of `AskForm`. */
+interface AskFormSlots {
+  /** Your own form body, given the form's state, in place of the default. */
+  default?: (state: AskFormState) => VNode[];
+}
+/**
+ * The form to answer one ask: its fields, in steps when `fields-per-step` is
+ * set, then submit, and dismiss when the ask allows it. It checks each step's
+ * answers before moving on, and shows a failed submit or dismissal in plain
+ * copy.
+ */
+export declare const AskForm: PublicComponent<AskFormProps, AskFormSlots>;
+/** What the `ChatComposer` default slot receives. */
+interface ChatComposerState {
+  /** The text being written. */
+  draft: string;
+  /** Changes the text. */
+  setDraft: (value: string) => void;
+  /**
+   * Sends the draft with any ready attachments, then clears both. Does nothing
+   * when the draft is empty, a send is in flight, or an upload is still in
+   * progress.
+   */
+  send: () => Promise<void>;
+  /** Whether a send is in flight. */
+  sending: boolean;
+  /** Why the last send failed; the draft is kept to send again. */
+  error: DropByError | null;
+  /** The attachments passed in, if any. */
+  attachments: ChatAttachmentsToolkit | undefined;
+}
+declare const chatComposerProps: {
+  /** The conversation to send to. */
+  readonly threadId: {
+    readonly type: PropType<DropById<"thr_">>;
+    readonly required: true;
+  };
+  /**
+   * Attachments from `useChatAttachments`, in
+   * `@dropby/vue/components/chat-attachments`. Omit for a text-only composer.
+   */
+  readonly attachments: {
+    readonly type: PropType<ChatAttachmentsToolkit>;
+    readonly default: undefined;
+  };
+};
+/** Props for `ChatComposer`; other attributes go to its `form`. */
+type ChatComposerProps = ExtractPublicPropTypes<typeof chatComposerProps>;
+/** Slots of `ChatComposer`. */
+interface ChatComposerSlots {
+  /** Your own form body, given the draft and `send`, in place of the default. */
+  default?: (state: ChatComposerState) => VNode[];
+}
+/**
+ * A message box for one conversation. A message needs text, and sending is blocked
+ * while an upload is in progress; with `attachments`, it sends those that are
+ * ready. A failed send keeps the draft and shows plain copy; sending the same text
+ * and attachments again reuses the failed send's key, so a send whose answer was
+ * lost is not posted twice while this composer stays mounted.
+ */
+export declare const ChatComposer: PublicComponent<ChatComposerProps, ChatComposerSlots>;
+/** What the `ChatThread` default slot receives. */
+interface ChatThreadState {
+  /** The load of older messages, once one started. */
+  olderMessages: ChatHistoryLoadState | undefined;
+  /** The load of the newest messages, once one started. */
+  latestMessages: ChatHistoryLoadState | undefined;
+  /** The conversation as loaded. */
+  thread: AsyncResource<ChatThread$1> | undefined;
+  /** The conversation's actions. */
+  actions: ChatThreadActions;
+}
+declare const chatThreadProps: {
+  /** The conversation to show. */
+  readonly id: {
+    readonly type: PropType<DropById<"thr_">>;
+    readonly required: true;
+  };
+  /** Do not open the conversation on mount; call `actions.open()` yourself. */
+  readonly manualLoad: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+  /**
+   * Marks replies seen once they are read on screen; true by default. Pass
+   * false to call `actions.markSeen` yourself.
+   */
+  readonly acknowledge: {
+    readonly type: BooleanConstructor;
+    readonly default: true;
+  };
+};
+/**
+ * Props for `ChatThread`; other attributes go to its `div`, or to your slot's root
+ * element when it has exactly one.
+ */
+type ChatThreadProps = ExtractPublicPropTypes<typeof chatThreadProps>;
+/** Slots of `ChatThread`. */
+interface ChatThreadSlots {
+  /**
+   * Replaces the default body, composer included, given the conversation and
+   * its actions. A slot body is never watched for reading.
+   */
+  default?: (state: ChatThreadState) => VNode[];
+}
+/**
+ * One conversation: its messages, each with `data-author` and any attachments, in
+ * a live region, then a text-only composer. It opens the conversation on mount
+ * unless `manual-load`, and shows the load in `data-status`. When the thread or an
+ * element around it scrolls (`overflow-y: auto` or `scroll`), the default body
+ * follows new messages while the reader is at the end, or when the message is
+ * their own; it never scrolls the page. It marks replies seen once they are read
+ * on screen.
+ */
+export declare const ChatThread: PublicComponent<ChatThreadProps, ChatThreadSlots>;
+/** What the `ChatThreadList` default slot receives. */
+interface ChatThreadListState {
+  /** The conversation list. */
+  threads: ChatThreadsCollection;
+  /** Chat's actions. */
+  actions: ChatActions;
+}
+declare const chatThreadListProps: {
+  /** Do not load the list on mount; call `actions.listThreads()` yourself. */
+  readonly manualLoad: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+  /** The conversation open now, marked `aria-current`; used only with `@select`. */
+  readonly selectedId: {
+    readonly type: PropType<DropById<"thr_"> | null>;
+    readonly default: null;
+  };
+  /** Bound by `@select`: makes each row a button that emits its conversation's id. */
+  readonly onSelect: {
+    readonly type: PropType<(threadId: DropById<"thr_">) => void>;
+  };
+};
+/**
+ * Props for `ChatThreadList`; other attributes go to its `ul`, or to your slot's
+ * root element when it has exactly one.
+ */
+type ChatThreadListProps = ExtractPublicPropTypes<typeof chatThreadListProps>;
+/** Slots of `ChatThreadList`. */
+interface ChatThreadListSlots {
+  /** Your own list, given the conversations and chat's actions, in place of the default. */
+  default?: (state: ChatThreadListState) => VNode[];
+}
+/**
+ * The user's conversations, newest first, a page at a time. It starts with a
+ * refresh button and an unread filter (`aria-pressed`), marks rows with unread
+ * replies `data-unread`, loads on mount unless `manual-load`, shows the load in
+ * `data-status` and `data-empty`, and ends with a "show more conversations" item
+ * (`data-load-more`) while there are more, which also retries a page that failed.
+ */
+export declare const ChatThreadList: PublicComponent<ChatThreadListProps, ChatThreadListSlots>;
+declare const featureProps: {
+  /** The feature flag to read. */
+  readonly name: {
+    readonly type: StringConstructor;
+    readonly required: true;
+  };
+  /** The value that turns it on; without it, any truthy value does. */
+  readonly equals: {
+    readonly type: PropType<FlagValue>;
+    readonly default: undefined;
+  };
+};
+/** Props for `Feature`. */
+type FeatureProps = ExtractPublicPropTypes<typeof featureProps>;
+/** Slots of `Feature`. */
+interface FeatureSlots {
+  /** What to render when the flag is on. */
+  default?: () => VNode[];
+  /** What to render when the flag is off, unset, or not yet read. */
+  fallback?: () => VNode[];
+}
+/**
+ * Renders its default slot when a feature flag is on: equal to `equals` when
+ * given, otherwise truthy. Renders the `fallback` slot otherwise, including until
+ * the session has loaded. It adds no markup of its own and takes no attributes.
+ */
+export declare const Feature: PublicComponent<FeatureProps, FeatureSlots>;
+declare const ideaProps: {
+  /** The idea to show. */
+  readonly idea: {
+    readonly type: PropType<Idea$1>;
+    readonly required: true;
+  };
+};
+/** Props for `Idea`; other attributes go to its `div`. */
+type IdeaProps = ExtractPublicPropTypes<typeof ideaProps>;
+/** Slots of `Idea`. */
+interface IdeaSlots {
+  /** Your own body, given the idea, in place of the default. */
+  default?: (state: {
+    idea: Idea$1;
+  }) => VNode[];
+}
+/**
+ * One idea: its vote button, title and description, with `data-voted` when the
+ * user voted. In your own body, use `IdeaVoteButton` for voting.
+ */
+export declare const Idea: PublicComponent<IdeaProps, IdeaSlots>;
+/** What the `IdeaList` default slot receives. */
+interface IdeaListState {
+  /** The ideas list. */
+  ideas: PagedCollection<Idea$1>;
+  /** The board's actions. */
+  actions: IdeasActions;
+}
+declare const ideaListProps: {
+  /**
+   * The user's ideas, or the public board; `owned` by default. Used only when the
+   * ideas store has not loaded yet; to switch later, call `actions.list({ view
+   * })`.
+   */
+  readonly view: {
+    readonly type: PropType<ListIdeasView>;
+    readonly default: undefined;
+  };
+  /** Do not load on mount; call `actions.list()` yourself. */
+  readonly manualLoad: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+};
+/**
+ * Props for `IdeaList`; other attributes go to its `ul`, or to your slot's root
+ * element when it has exactly one.
+ */
+type IdeaListProps = ExtractPublicPropTypes<typeof ideaListProps>;
+/** Slots of `IdeaList`. */
+interface IdeaListSlots {
+  /** Your own list, given the ideas and the board's actions, in place of the default. */
+  default?: (state: IdeaListState) => VNode[];
+}
+/**
+ * Ideas, each an `Idea`, a page at a time: the board by votes, the user's ideas
+ * newest first. It loads on mount unless `manual-load`, shows the load in
+ * `data-status` and `data-empty`, and ends with a "show more ideas" item
+ * (`data-load-more`) while there are more.
+ */
+export declare const IdeaList: PublicComponent<IdeaListProps, IdeaListSlots>;
+/** What the `IdeaVoteButton` default slot receives: one idea's vote. */
+interface IdeaVoteState {
+  /** The idea. */
+  idea: Idea$1;
+  /** Whether the user voted for it. */
+  voted: boolean;
+  /** Whether the user can vote on it. */
+  votable: boolean;
+  /** Whether a vote is in flight. */
+  voting: boolean;
+  /** Why the last vote failed. */
+  error: DropByError | null;
+  /** Adds the user's vote. */
+  vote: () => Promise<void>;
+  /** Takes the user's vote back. */
+  unvote: () => Promise<void>;
+  /** Votes, or takes the vote back. */
+  toggle: () => Promise<void>;
+}
+declare const ideaVoteButtonProps: {
+  /** The idea to vote on. */
+  readonly idea: {
+    readonly type: PropType<Idea$1>;
+    readonly required: true;
+  };
+};
+/** Props for `IdeaVoteButton`; other attributes go to its `button`. */
+type IdeaVoteButtonProps = ExtractPublicPropTypes<typeof ideaVoteButtonProps>;
+/** Slots of `IdeaVoteButton`. */
+interface IdeaVoteButtonSlots {
+  /** Your own content, given the vote state, in place of the vote count. */
+  default?: (state: IdeaVoteState) => VNode[];
+}
+/**
+ * A button that votes for an idea, or takes the vote back. It shows the vote
+ * count, is disabled while a vote is in flight or when the user cannot vote,
+ * and exposes its state in `aria-pressed`, `aria-busy`, `data-voted` and
+ * `data-busy`. Your own `@click` runs first and can cancel the vote with
+ * `preventDefault()`; your own `disabled` wins over its own.
+ */
+export declare const IdeaVoteButton: PublicComponent<IdeaVoteButtonProps, IdeaVoteButtonSlots>;
+/** What the `PendingAsks` default slot receives. */
+interface PendingAsksState {
+  /** The asks waiting for the user. */
+  asks: PendingAsksCollection;
+  /** The asks' actions. */
+  actions: AsksActions;
+}
+declare const pendingAsksProps: {
+  /** Passed to each ask's form. */
+  readonly fieldsPerStep: {
+    readonly type: NumberConstructor;
+    readonly default: undefined;
+  };
+  /** Do not load on mount; call `actions.listPending()` yourself. */
+  readonly manualLoad: {
+    readonly type: BooleanConstructor;
+    readonly default: false;
+  };
+};
+/**
+ * Props for `PendingAsks`; other attributes go to its `ul`, or to your slot's root
+ * element when it has exactly one.
+ */
+type PendingAsksProps = ExtractPublicPropTypes<typeof pendingAsksProps>;
+/** Slots of `PendingAsks`. */
+interface PendingAsksSlots {
+  /** Your own list, given the asks and their actions, in place of the default. */
+  default?: (state: PendingAsksState) => VNode[];
+}
+/**
+ * The asks waiting for the user, each an `Ask`, a page at a time. It loads on
+ * mount unless `manual-load`, shows the load in `data-status` and `data-empty`,
+ * and ends with a "show more asks" item (`data-load-more`) while there are
+ * more.
+ */
+export declare const PendingAsks: PublicComponent<PendingAsksProps, PendingAsksSlots>;
+export type { AskAnswerValue, AskAnswers, AskFormProps, AskFormSlots, AskFormState, AskProps, AskSlots, ChatAttachmentDraft, ChatAttachmentsToolkit, ChatComposerProps, ChatComposerSlots, ChatComposerState, ChatThreadListProps, ChatThreadListSlots, ChatThreadListState, ChatThreadProps, ChatThreadSlots, ChatThreadState, FeatureProps, FeatureSlots, IdeaListProps, IdeaListSlots, IdeaListState, IdeaProps, IdeaSlots, IdeaVoteButtonProps, IdeaVoteButtonSlots, IdeaVoteState, PendingAsksProps, PendingAsksSlots, PendingAsksState };