@octans/ui 1.0.0

package/dist/components/LineClamper/types.d.ts

@@ -0,0 +1,7 @@
+export interface LineClamperProps {
+    /**
+     * Number of lines to clamp the text to.
+     * @default 2
+     */
+    lines?: number;
+}

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

@@ -0,0 +1,19 @@
+export interface LinkProps {
+    url: string;
+    external?: boolean;
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<LinkProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LinkProps> & Readonly<{}>, {
+    external: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Link/index.d.ts

@@ -0,0 +1 @@
+export { default as Link, default as PageLink } from './Link.vue';

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

@@ -0,0 +1,15 @@
+import { ListItemType, ListProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<ListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "select-item": (item: ListItemType) => any;
+}, string, import('vue').PublicProps, Readonly<ListProps> & Readonly<{
+    "onSelect-item"?: ((item: ListItemType) => any) | undefined;
+}>, {
+    type: import('./types').ListType;
+    tight: boolean;
+    maxItems: number;
+    inCard: boolean;
+    inCardSection: boolean;
+    selectable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/List/ListItem.vue.d.ts

@@ -0,0 +1,16 @@
+import { ListItemProps } from './types';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<ListItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ListItemProps> & Readonly<{}>, {
+    listType: import('./types').ListType;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/List/index.d.ts

@@ -0,0 +1,3 @@
+export { default as List } from './List.vue';
+export { default as ListItem } from './ListItem.vue';
+export * from './types';

package/dist/components/List/types.d.ts

@@ -0,0 +1,51 @@
+export type ListType = 'bullet' | 'number' | 'error';
+export interface ListItemType {
+    label?: string;
+    content?: string;
+    idLabel?: string | null;
+    [key: string]: any;
+}
+export interface ListProps {
+    /**
+     * The style to render the list.
+     */
+    type?: ListType;
+    /**
+     * Optionally bound the list to data.
+     */
+    items?: ListItemType[];
+    /**
+     * The maximum number of items to display. If  the list is truncated
+     * `moreItemsText` will be added to the bottom.
+     */
+    maxItems?: number;
+    /**
+     * The text to render when there are no items to display. Set to falsy
+     * to disable.
+     */
+    emptyText?: string;
+    /**
+     * The text to render when items are truncated. The `{count}` symbol is replaced
+     * by the number of items that were truncated.
+     */
+    moreItemsText?: string;
+    /**
+     * If enabled the list is rendered with condensed spacing.
+     */
+    tight?: boolean;
+    /**
+     * Adds a separator between each item as well as padding so they can be
+     * rendered in a card.
+     */
+    inCard?: boolean;
+    /**
+     * Same as `inCard` but also negates the horizontal padding that the card
+     * section provides.
+     */
+    inCardSection?: boolean;
+    selectable?: boolean;
+}
+export interface ListItemProps {
+    item?: ListItemType;
+    listType?: ListType;
+}

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

@@ -0,0 +1,18 @@
+import { LoaderOverlayProps } from './types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<LoaderOverlayProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LoaderOverlayProps> & Readonly<{}>, {
+    visible: boolean;
+    message: string;
+    fullscreen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LoaderOverlay/host.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The overlay `$ui.loader.show()` falls back to when no `<LoaderOverlay>` is
+ * mounted anywhere — fixed over the whole viewport. An `AppFrame` (or any
+ * consumer-placed overlay) mounting later takes over and this one retires.
+ */
+export declare const ensureHost: () => void, teardownHost: () => void;

package/dist/components/LoaderOverlay/index.d.ts

@@ -0,0 +1,26 @@
+export { default as LoaderOverlay } from './LoaderOverlay.vue';
+export type { LoaderOverlayProps } from './types';
+/**
+ * The global blocking loader, also exposed as `$ui.loader`. `show()` covers
+ * the page with a dimmed overlay and a spinner until `hide()`.
+ *
+ * Renders in any mounted `<LoaderOverlay>` — `AppFrame` includes one covering
+ * its content area — and when none exists, a full-viewport overlay is mounted
+ * on first use, so nothing has to be placed in the page for this to work.
+ */
+export declare const loader: {
+    /** Whether the overlay is currently showing. Reactive. */
+    readonly visible: boolean;
+    show(message?: string): void;
+    hide(): void;
+};
+/**
+ * Composable form of `$ui.loader` — the same shared overlay state, with
+ * `visible` as a ref, so destructuring keeps it reactive.
+ */
+export declare function useLoader(): {
+    /** Whether the overlay is currently showing. */
+    visible: import('vue').ComputedRef<boolean>;
+    show: (message?: string) => void;
+    hide: () => void;
+};

package/dist/components/LoaderOverlay/store.d.ts

@@ -0,0 +1,7 @@
+export declare const loaderState: {
+    readonly visible: boolean;
+    readonly message: string;
+};
+export declare const loaderHosts: import('../../utils/autoHost').HostRegistryType;
+export declare function showLoader(message?: string): void;
+export declare function hideLoader(): void;

package/dist/components/LoaderOverlay/types.d.ts

@@ -0,0 +1,24 @@
+export interface LoaderOverlayProps {
+    /**
+     * Shows the overlay directly, independent of `$ui.loader`. The overlay is
+     * visible when either this is true or `$ui.loader.show()` has been called.
+     *
+     * @default false
+     */
+    visible?: boolean;
+    /**
+     * Text under the spinner when the overlay was shown by the `visible` prop,
+     * or when `$ui.loader.show()` was called without a message.
+     *
+     * @default 'Loading...'
+     */
+    message?: string;
+    /**
+     * Cover the whole viewport rather than the nearest positioned ancestor.
+     * This is what the auto-mounted overlay uses; the one inside `AppFrame`
+     * covers only the content area, leaving the nav usable.
+     *
+     * @default false
+     */
+    fullscreen?: boolean;
+}

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

@@ -0,0 +1,7 @@
+import { LoadingBarProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<LoadingBarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LoadingBarProps> & Readonly<{}>, {
+    fixed: boolean;
+    height: number | string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/LoadingBar/host.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The bar `$ui.progress.start()` falls back to when no `<LoadingBar>` is
+ * mounted anywhere — fixed to the top of the viewport. A `GlobalNav` (or any
+ * consumer-placed bar) mounting later takes over and this one retires.
+ */
+export declare const ensureHost: () => void, teardownHost: () => void;

package/dist/components/LoadingBar/index.d.ts

@@ -0,0 +1,28 @@
+export { default as LoadingBar } from './LoadingBar.vue';
+export type { LoadingBarProps } from './types';
+/**
+ * The global page-load trickle, also exposed as `$ui.progress`. Call `start()`
+ * when a navigation or long fetch begins and `done()` when it lands; the bar
+ * creeps toward 99% on its own in between.
+ *
+ * Renders in any mounted `<LoadingBar>` — `GlobalNav` includes one — and when
+ * none exists, a bar fixed to the top of the viewport is mounted on first use,
+ * so nothing has to be placed in the page for this to work.
+ */
+export declare const progress: {
+    /** The current bar position, 0–100. 0 means idle. Reactive — a getter into
+     * the shared store, so it works in computeds and templates. */
+    readonly value: number;
+    start(): void;
+    done(): void;
+};
+/**
+ * Composable form of `$ui.progress` — the same shared trickle, with the
+ * position as a ref, so destructuring keeps it reactive.
+ */
+export declare function useProgress(): {
+    /** The current bar position, 0–100. 0 means idle. */
+    value: import('vue').ComputedRef<number>;
+    start: () => void;
+    done: () => void;
+};

package/dist/components/LoadingBar/store.d.ts

@@ -0,0 +1,6 @@
+export declare const loadingBarState: {
+    readonly value: number;
+};
+export declare const loadingBarHosts: import('../../utils/autoHost').HostRegistryType;
+export declare function startProgress(): void;
+export declare function doneProgress(): void;

package/dist/components/LoadingBar/types.d.ts

@@ -0,0 +1,16 @@
+export interface LoadingBarProps {
+    /**
+     * Pin the bar to the top of the viewport rather than the top of its nearest
+     * positioned ancestor. This is what the auto-mounted bar uses; set it when
+     * placing your own bar outside any chrome.
+     *
+     * @default false
+     */
+    fixed?: boolean;
+    /**
+     * Thickness of the bar — a number of pixels, or any CSS length.
+     *
+     * @default 4
+     */
+    height?: number | string;
+}

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

@@ -0,0 +1,53 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * Renders the content in a `<MountingPortal>` if `true` otherwise renders
+     * the content in a `<div>`.
+     */
+    teleport: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mountTo: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Defers mounting the teleported content until the rest of the app has
+     * rendered, so `mountTo` can point at a target that only exists after the
+     * same render cycle. Content is still in the DOM by `nextTick()`.
+     */
+    defer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * Renders the content in a `<MountingPortal>` if `true` otherwise renders
+     * the content in a `<div>`.
+     */
+    teleport: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mountTo: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Defers mounting the teleported content until the rest of the app has
+     * rendered, so `mountTo` can point at a target that only exists after the
+     * same render cycle. Content is still in the DOM by `nextTick()`.
+     */
+    defer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    defer: boolean;
+    teleport: boolean;
+    mountTo: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/MaybeMountingPortal/index.d.ts

@@ -0,0 +1 @@
+export { default as MaybeMountingPortal } from './MaybeMountingPortal.vue';

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

@@ -0,0 +1,34 @@
+import { MaybeRouterLinkProps } from './types';
+declare var __VLS_9: any, __VLS_19: any, __VLS_21: {
+    href?: string;
+    isActive: boolean;
+    isExactActive: boolean;
+}, __VLS_30: {
+    href?: string;
+    isActive: boolean;
+    isExactActive: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_19) => any;
+} & {
+    default?: (props: typeof __VLS_21) => any;
+} & {
+    default?: (props: typeof __VLS_30) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<MaybeRouterLinkProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MaybeRouterLinkProps> & Readonly<{}>, {
+    plain: boolean;
+    tag: string;
+    custom: boolean;
+    exactPath: boolean;
+    matchRoutes: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/MaybeRouterLink/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MaybeRouterLink } from './MaybeRouterLink.vue';
+export * from './types';

package/dist/components/MaybeRouterLink/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A structural stand-in for vue-router's `RouteLocationRaw`.
+ *
+ * Declared locally on purpose: `vue-router` is an *optional* peer dependency,
+ * so importing its types here would put an unresolvable import in the published
+ * `.d.ts` and break typechecking for consumers who don't use a router. This
+ * shape is assignable from a real `RouteLocationRaw`.
+ */
+export type RouteLocationType = string | ({
+    path?: string;
+    name?: string | symbol;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    hash?: string;
+    replace?: boolean;
+    /** Forces the link to be treated as external. */
+    external?: boolean;
+} & Record<string, any>);
+export interface MaybeRouterLinkProps {
+    /**
+     * The target location of the route. See https://router.vuejs.org/api/#to
+     * for usage.
+     * TODO:
+     * // Location type?
+     */
+    to?: RouteLocationType;
+    /**
+     * Render the link as another tag type, e.g. `<div>`.
+     */
+    tag?: string;
+    /**
+     * Enables custom rendering of the link and prevents the default output
+     * which wraps the slot content with `tag`.
+     */
+    custom?: boolean;
+    /**
+     * Allows matching only using the path section of the url, effectively
+     * ignoring the query and the hash sections.
+     */
+    exactPath?: boolean;
+    /**
+     * Removes the defaylt link styling of `<a>` tags.
+     */
+    plain?: boolean;
+    /**
+     * Set to `false` to disable route-based matching to determine active states.
+     */
+    matchRoutes?: boolean;
+}

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

@@ -0,0 +1,28 @@
+import { ModalProps } from './types';
+declare var __VLS_41: {}, __VLS_43: {}, __VLS_45: {};
+type __VLS_Slots = {} & {
+    preBody?: (props: typeof __VLS_41) => any;
+} & {
+    default?: (props: typeof __VLS_43) => any;
+} & {
+    footer?: (props: typeof __VLS_45) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<ModalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    afterLeave: () => any;
+    afterEnter: () => any;
+}, string, import('vue').PublicProps, Readonly<ModalProps> & Readonly<{
+    onAfterLeave?: (() => any) | undefined;
+    onAfterEnter?: (() => any) | undefined;
+}>, {
+    loading: boolean;
+    noHeader: boolean;
+    overflowVisible: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Modal/ModalBackdrop.vue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The dimmed sheet behind a modal. Lives in its own component because there are
+ * two owners: a standalone `<Modal>` draws its own, and `<ModalHost>` draws a
+ * single one for the whole stack — N modals must not compound into N layers of
+ * dimming.
+ */
+type __VLS_Props = {
+    visible: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Modal/ModalHost.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Modal/ModalStackItem.vue.d.ts

@@ -0,0 +1,14 @@
+import { ModalEntry } from './manager';
+/**
+ * One entry in the stack. It exists to be a component boundary: the `<Modal>`
+ * inside needs to know its own depth and needs somewhere to register its close
+ * and focus handlers, and `provide` is per-component, so the host cannot do it
+ * for all of them at once.
+ */
+type __VLS_Props = {
+    entry: ModalEntry;
+    depth: number;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Modal/api/AlertModal.vue.d.ts

@@ -0,0 +1,10 @@
+import { AlertModalProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<AlertModalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    action: (result?: string | boolean | undefined) => any;
+    afterLeave: () => any;
+}, string, import('vue').PublicProps, Readonly<AlertModalProps> & Readonly<{
+    onAction?: ((result?: string | boolean | undefined) => any) | undefined;
+    onAfterLeave?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Modal/api/Base.d.ts

@@ -0,0 +1,12 @@
+import { ModalEmits } from './types';
+export declare const RenderNode: import('vue').DefineComponent<{
+    node?: any;
+}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    node?: any;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare function useBaseModal(emit: ModalEmits): {
+    handleAction: (result?: string | boolean) => void;
+    handleLeave: () => void;
+};

package/dist/components/Modal/api/ConfirmModal.vue.d.ts

@@ -0,0 +1,10 @@
+import { ConfirmModalProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<ConfirmModalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    action: (result?: string | boolean | undefined) => any;
+    afterLeave: () => any;
+}, string, import('vue').PublicProps, Readonly<ConfirmModalProps> & Readonly<{
+    onAction?: ((result?: string | boolean | undefined) => any) | undefined;
+    onAfterLeave?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Modal/api/GenericModal.vue.d.ts

@@ -0,0 +1,10 @@
+import { GenericModalProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<GenericModalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    action: (result?: string | boolean | undefined) => any;
+    afterLeave: () => any;
+}, string, import('vue').PublicProps, Readonly<GenericModalProps> & Readonly<{
+    onAction?: ((result?: string | boolean | undefined) => any) | undefined;
+    onAfterLeave?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Modal/api/PromptModal.vue.d.ts

@@ -0,0 +1,10 @@
+import { PromptModalProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<PromptModalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    action: (result?: string | boolean | undefined) => any;
+    afterLeave: () => any;
+}, string, import('vue').PublicProps, Readonly<PromptModalProps> & Readonly<{
+    onAction?: ((result?: string | boolean | undefined) => any) | undefined;
+    onAfterLeave?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;