@bluerobotics/bluevue 0.1.1 → 0.2.1

package/dist/components/BlueRadioGroup.vue.d.ts

@@ -0,0 +1,40 @@
+/** One of the choices in the group. */
+export interface BlueRadioItem {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    /** Why the choice is what it sounds like, or why it is out of reach. */
+    hint?: string;
+}
+/**
+ * One choice out of a few, each spelled out. Where a BlueButtonGroup packs the options into a
+ * track, this gives every one of them a line of its own, which is what a choice needing an
+ * explanation apiece wants.
+ */
+type __VLS_Props = {
+    modelValue: string | number | null;
+    items: BlueRadioItem[];
+    /** Name of the group, which is what makes the choices exclusive. */
+    name: string;
+    /** Label above the choices. */
+    label?: string;
+    /** Lays the choices out along a row instead of down a column. */
+    inline?: boolean;
+    disabled?: boolean;
+    theme?: 'light' | 'dark';
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/BlueSection.vue.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A subject inside a panel: a quiet heading over a stack of rows. Smaller than a
+ * BlueExpansiblePanel, which is a section of the page rather than a part of one, and not foldable.
+ */
+type __VLS_Props = {
+    title: string;
+    /** Space between the rows, in pixels (default 12). */
+    gap?: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        notes?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BlueSnackbar.vue.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Puts the application's notices on screen, newest nearest the edge. Mount it once, at the root;
+ * BlueApp already does. Raising a notice is useBlueSnackbar's job, from wherever it happened.
+ */
+type __VLS_Props = {
+    /** Which corner they gather in (default 'bottom-right'). */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/BlueSpinner.vue.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A turning ring, for a wait with no measure to it. A wait that does have one belongs in a
+ * BlueProgressBar, and one that blocks the whole page in a BlueLoadingDialog.
+ */
+type __VLS_Props = {
+    /** Diameter, in pixels when given as a number (default 20). */
+    size?: number | string;
+    /** The colour of the arc that turns (default the accent token). */
+    color?: string;
+    /** Ring thickness in pixels (default 2). */
+    width?: number;
+    /** What is being waited for, read out by assistive technology. */
+    label?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/BlueStat.vue.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One read-only fact about the vehicle: a quiet label over its value. Meant to sit in a row of
+ * them, each taking an equal share of the width and wrapping to the next line when there is none.
+ */
+type __VLS_Props = {
+    label: string;
+    value?: string | number | null;
+    /** What to show when there is no value yet (default an em dash). */
+    placeholder?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/BlueStepsDialog.vue.d.ts

@@ -0,0 +1,62 @@
+/** One stage of the work, in the order it runs. */
+export interface BlueStep {
+    key: string;
+    title: string;
+    state: 'pending' | 'running' | 'done' | 'failed' | 'skipped';
+    /** What the step is doing, or why it failed. */
+    detail?: string;
+}
+/**
+ * Reports on work with stages to it: installing firmware, writing parameters, restarting. The
+ * dialog holds the page while the work is running and lets go the moment it is not, so a run that
+ * ends in a failure can be read, retried or skipped from the footer.
+ */
+type __VLS_Props = {
+    modelValue: boolean;
+    title: string;
+    /** What the current stage is doing, under the title. */
+    subtitle?: string;
+    /** Running holds the page; the other two release it. */
+    state: 'running' | 'failed' | 'done';
+    steps: BlueStep[];
+    /** The line above the bar, naming what is being worked through. */
+    progressLabel?: string;
+    /** Percentage of the current stage, when the stage can count itself. */
+    progress?: number;
+    /** For a stage that can only say it is waiting, such as a restart. */
+    indeterminate?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        badges?(_: {}): any;
+        log?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        logRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BlueTable.vue.d.ts

@@ -0,0 +1,62 @@
+/** One column of the table. */
+export interface BlueColumn {
+    /** The field it reads from each row, and the name of its cell slot. */
+    key: string;
+    title: string;
+    width?: string;
+    align?: 'start' | 'center' | 'end';
+    /** Lets the header be pressed to order the rows by this column. */
+    sortable?: boolean;
+}
+/**
+ * Rows of records under a header that stays put while they scroll. Sorting is its own, so a
+ * consumer hands it a list and gets an ordered table without keeping the order itself.
+ */
+type __VLS_Props = {
+    columns: BlueColumn[];
+    rows: Record<string, unknown>[];
+    /** The field that identifies a row. Falls back to the row's place in the list. */
+    rowKey?: string;
+    /** Column to order by before anyone presses a header. */
+    sortBy?: string;
+    /** How tall the body may get before it scrolls under its header. */
+    maxHeight?: string;
+    /** Tighter rows, for a table of many short ones. */
+    dense?: boolean;
+    /** What to say instead of an empty body. */
+    emptyText?: string;
+    theme?: 'light' | 'dark';
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`cell-${string}`, (_: {
+        row: Record<string, unknown>;
+        value: unknown;
+    }) => any>> & {
+        empty?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "row-click": (row: Record<string, unknown>) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onRow-click"?: ((row: Record<string, unknown>) => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BlueTabs.vue.d.ts

@@ -0,0 +1,37 @@
+/** One tab in the strip. */
+export interface BlueTab {
+    /** What comes back through v-model when it is chosen. */
+    value: string | number;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    /** A count beside the label, such as how many things the tab holds. */
+    badge?: string | number;
+}
+/**
+ * The strip that switches between the pages of a view. It reports which tab is current and
+ * nothing else: what each one shows is the consumer's, since a tab that renders its page only
+ * when it is current is what keeps the ones behind it from doing work.
+ */
+type __VLS_Props = {
+    modelValue: string | number;
+    tabs: BlueTab[];
+    /** Fills the width it is given, each tab taking an equal share. */
+    stretch?: boolean;
+    theme?: 'light' | 'dark';
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/BlueTextarea.vue.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A BlueInput with room for several lines: the same well cut into the panel, for a note, a
+ * description, or a block of parameters pasted in.
+ */
+type __VLS_Props = {
+    modelValue: string | null;
+    /** Label above the field, since a multi-line field beside its label leaves the label floating. */
+    label?: string;
+    /** Name and id, tying the label to the field. */
+    name?: string;
+    placeholder?: string;
+    /** Lines of room it starts with (default 4). */
+    rows?: number;
+    /** Grows with its content instead of scrolling, up to maxRows. */
+    autoGrow?: boolean;
+    /** How far autoGrow goes before the field starts scrolling (default 12). */
+    maxRows?: number;
+    disabled?: boolean;
+    /** Validation messages, which also outline the field. */
+    errorMessages?: string[];
+    /** A hint behind an info icon beside the label. */
+    infoTooltip?: string;
+    width?: string;
+    theme?: 'light' | 'dark';
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/BlueTooltip.vue.d.ts

@@ -0,0 +1,44 @@
+import { Placement } from '@floating-ui/vue';
+/**
+ * A label for whatever it wraps, shown on hover and on keyboard focus. It opens in the top layer,
+ * so a panel that clips its own overflow cannot cut it off.
+ */
+type __VLS_Props = {
+    text: string;
+    /** Which side it hangs off (default 'top'). */
+    placement?: Placement;
+    /** How long the pointer has to rest before it appears, in ms (default 300). */
+    openDelay?: number;
+    /** Wraps its content and shows nothing, for a hint that only applies sometimes. */
+    disabled?: boolean;
+    theme?: 'light' | 'dark';
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        anchorRef: HTMLSpanElement;
+        popoverRef: HTMLDivElement;
+    };
+    rootEl: HTMLSpanElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BlueWindRose.vue.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A heading around a circle: typed in the field, or pointed on the rose that opens from the
+ * compass beside it. The value wraps at the ends, so 360° and 0° are the same direction.
+ */
+type __VLS_Props = {
+    modelValue: number | null;
+    label?: string;
+    name?: string;
+    /** Start of the circle (default 0). */
+    min?: number;
+    /** End of the circle, wrapping back to min (default 360). */
+    max?: number;
+    step?: number;
+    suffix?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    theme?: 'light' | 'dark';
+    height?: string;
+    width?: string;
+    infoTooltip?: string;
+    errorMessages?: string[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/composables/useBlueLoading.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+export interface BlueLoadingState {
+    show: boolean;
+    message: string;
+    dismissible: boolean;
+}
+interface BlueLoadingApi {
+    loading: Readonly<Ref<BlueLoadingState>>;
+    /**
+     * Raises the overlay. Leave it blocking for anything that is writing to a vehicle: dismissing it
+     * would leave the page live over a change still in flight. A wait that only delays information,
+     * such as the first read of a vehicle, can be dismissible.
+     */
+    showLoading: (message?: string, dismissible?: boolean) => void;
+    hideLoading: () => void;
+}
+/**
+ * The application's blocking wait, which BlueApp renders as a BlueLoadingDialog.
+ * @returns {BlueLoadingApi} The state, and the ways to raise and lower it.
+ */
+export declare function useBlueLoading(): BlueLoadingApi;
+export {};

package/dist/composables/useBlueOs.d.ts

@@ -0,0 +1,39 @@
+import { Ref } from 'vue';
+import { BlueOsError } from '../services/blueos';
+export interface BlueOsHost {
+    /** What the vehicle is called, which is what an extension should call it too. */
+    vehicleName: Ref<string | null>;
+    /** The address the vehicle answers to, without the .local suffix. */
+    hostname: Ref<string | null>;
+    /** The BlueOS image currently running, as its docker tag. */
+    version: Ref<string | null>;
+    /** The vehicle's primary colour, as #RRGGBB. Null until it arrives, and when it cannot. */
+    primaryColor: Ref<string | null>;
+    /** Whether BlueOS itself is in dark mode. Extensions are drawn dark either way. */
+    isDarkTheme: Ref<boolean>;
+    /** Whether BlueOS is in pirate mode, which is what hides or shows developer-only controls. */
+    isPirateMode: Ref<boolean>;
+    /** Whether BlueOS is serving this page, as opposed to a development server. */
+    embedded: boolean;
+    /** Why the last identity read failed, or null while the vehicle answered. */
+    error: Ref<BlueOsError | null>;
+    /** Reads everything again, which a page does after something else may have changed it. */
+    refresh: () => Promise<void>;
+}
+/**
+ * What the vehicle running this extension says about itself. Read once when the first consumer
+ * mounts, and again whenever it is asked for, since none of it changes on its own. Each field
+ * stays at its default when that particular call fails, so a page opened off the vehicle still
+ * renders.
+ * @returns {BlueOsHost} The vehicle's name, address, version and look, and the means to read them again.
+ */
+export declare const useBlueOs: () => BlueOsHost;
+/**
+ * A value kept on the vehicle rather than in this browser, so an extension is configured once and
+ * found configured from every machine that opens it. It reads as the fallback until the stored
+ * value arrives, and writes itself back, at most twice a second, whenever it is changed.
+ * @param {string} path Where it is kept, as 'extension-name/setting'. Slashes nest.
+ * @param {T} fallback What it reads as while there is nothing stored, and if the read fails.
+ * @returns {Ref<T>} The value, which is written back on assignment.
+ */
+export declare const useBlueOsSetting: <T>(path: string, fallback: T) => Ref<T>;

package/dist/composables/useBlueSnackbar.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'vue';
+export type BlueNoticeSeverity = 'success' | 'error' | 'warning' | 'info';
+export interface BlueNotice {
+    id: number;
+    text: string;
+    severity: BlueNoticeSeverity;
+    /** How many of the same message arrived in a row, so a repeat counts rather than stacks. */
+    repeats: number;
+}
+interface BlueNoticeOptions {
+    /** Default 'info'. */
+    severity?: BlueNoticeSeverity;
+    /** How long it stays, in ms. 0 keeps it until it is dismissed, which errors do by default. */
+    timeout?: number;
+}
+interface BlueSnackbarApi {
+    notices: Readonly<Ref<readonly BlueNotice[]>>;
+    /** Says something happened. Returns the notice's id, for dismissing it early. */
+    notify: (text: string, options?: BlueNoticeOptions) => number;
+    /** Says a request failed, in whatever terms the failure came back in. */
+    notifyError: (error: unknown, fallback?: string) => number;
+    dismiss: (id: number) => void;
+}
+/**
+ * The application's notices. Raise them from anywhere; BlueSnackbar, which BlueApp mounts for you,
+ * is what puts them on screen.
+ * @returns {BlueSnackbarApi} The queue, and the ways to add to and remove from it.
+ */
+export declare function useBlueSnackbar(): BlueSnackbarApi;
+export {};

package/dist/index.d.ts

@@ -1,10 +1,40 @@
+export { default as BlueApp } from './components/BlueApp.vue';
+export { default as BlueBanner } from './components/BlueBanner.vue';
+export { default as BlueBannerGroup } from './components/BlueBannerGroup.vue';
+export { default as BlueButton } from './components/BlueButton.vue';
 export { default as BlueButtonGroup } from './components/BlueButtonGroup.vue';
+export { default as BlueCard } from './components/BlueCard.vue';
+export { default as BlueCheckbox } from './components/BlueCheckbox.vue';
+export { default as BlueChip } from './components/BlueChip.vue';
+export { default as BlueConfirmDialog } from './components/BlueConfirmDialog.vue';
+export { default as BlueDialog } from './components/BlueDialog.vue';
 export { default as BlueExpansiblePanel } from './components/BlueExpansiblePanel.vue';
+export { default as BlueFileDrop } from './components/BlueFileDrop.vue';
+export { default as BlueIcon } from './components/BlueIcon.vue';
 export { default as BlueInput } from './components/BlueInput.vue';
+export { default as BlueStepsDialog, type BlueStep } from './components/BlueStepsDialog.vue';
 export { default as BlueLoadingDialog } from './components/BlueLoadingDialog.vue';
 export { default as BlueMenu, type BlueMenuItem } from './components/BlueMenu.vue';
+export { default as BlueProgressBar } from './components/BlueProgressBar.vue';
 export { default as BluePromptDialog } from './components/BluePromptDialog.vue';
+export { default as BlueRadioGroup, type BlueRadioItem } from './components/BlueRadioGroup.vue';
+export { default as BlueSection } from './components/BlueSection.vue';
 export { default as BlueSelect } from './components/BlueSelect.vue';
 export { default as BlueSlider } from './components/BlueSlider.vue';
+export { default as BlueSnackbar } from './components/BlueSnackbar.vue';
+export { default as BlueSpinner } from './components/BlueSpinner.vue';
+export { default as BlueStat } from './components/BlueStat.vue';
 export { default as BlueSwitch } from './components/BlueSwitch.vue';
+export { default as BlueTable, type BlueColumn } from './components/BlueTable.vue';
+export { default as BlueTabs, type BlueTab } from './components/BlueTabs.vue';
+export { default as BlueTextarea } from './components/BlueTextarea.vue';
+export { default as BlueTooltip } from './components/BlueTooltip.vue';
+export { default as BlueWindRose } from './components/BlueWindRose.vue';
+export { type BlueLoadingState, useBlueLoading } from './composables/useBlueLoading';
+export { type BlueOsHost, useBlueOs, useBlueOsSetting } from './composables/useBlueOs';
 export { useBluePopover } from './composables/useBluePopover';
+export { type BlueNotice, type BlueNoticeSeverity, useBlueSnackbar } from './composables/useBlueSnackbar';
+export type { BannerContent, BannerSeverity } from './types/banner';
+export { BlueOsError, type BlueOsService, blueOsService, type BlueOsServiceOptions, isBlueOsExtension, setBlueOsHost, } from './services/blueos';
+export { downloadJson, pickJsonFile } from './utils/files';
+export { applyBlueTheme, type BlueTheme } from './utils/theme';

package/dist/services/blueos.d.ts

@@ -0,0 +1,37 @@
+/** What a BlueOS service answered when it did not answer with the thing that was asked for. */
+export declare class BlueOsError extends Error {
+    readonly url: string;
+    /** The HTTP status, or 0 when the service could not be reached at all. */
+    readonly status: number;
+    constructor(message: string, url: string, 
+    /** The HTTP status, or 0 when the service could not be reached at all. */
+    status: number);
+}
+export interface BlueOsServiceOptions {
+    /** The API version the service is versioned under. Pass null for the few that are not. */
+    version?: string | null;
+    /** How long a call may take before it is given up on, in milliseconds. */
+    timeout?: number;
+}
+export interface BlueOsService {
+    /** The absolute path a call would be made to, for a request this wrapper does not cover. */
+    url: (path: string) => string;
+    get: <T>(path: string, init?: RequestInit) => Promise<T>;
+    post: <T>(path: string, body?: unknown, init?: RequestInit) => Promise<T>;
+    delete: <T>(path: string, init?: RequestInit) => Promise<T>;
+}
+/**
+ * Points the services at a BlueOS that is not the origin serving this page, which is what a page
+ * running on a development server needs.
+ * @param {string} url The vehicle's address, such as 'http://blueos.local'. Empty means the origin.
+ */
+export declare const setBlueOsHost: (url: string) => void;
+/** Whether this page is being served by BlueOS as an extension, rather than run on its own. */
+export declare const isBlueOsExtension: () => boolean;
+/**
+ * A wrapper around one of BlueOS's services, reachable by name.
+ * @param {string} name The service as nginx exposes it, such as 'beacon', 'bag' or 'kraken'.
+ * @param {BlueOsServiceOptions} options The API version to address and how long to wait.
+ * @returns {BlueOsService} Its verbs, each parsing JSON and raising BlueOsError on anything else.
+ */
+export declare const blueOsService: (name: string, options?: BlueOsServiceOptions) => BlueOsService;