@webx-ui/module-admin 0.5.0 → 0.7.0

package/dist/AdminLanding.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What the panel opens on.
+ *
+ * Until now nothing answered at `/`: the routes are the modules', and no module claimed the
+ * root — so signing in landed on a blank page and the first thing anybody did was click a
+ * section. A module says which one that should be with `landing: true`, and here is where it
+ * is honoured.
+ *
+ * It waits for the manifest rather than redirecting on the spot, because what a panel has is
+ * something only the server knows: a landing module whose Composer half is not installed is
+ * not in the navigation, and sending somebody to a section that is not there would be worse
+ * than sending them nowhere. The fallback is the first entry of the menu, which is the section
+ * this panel would call its front page anyway.
+ */
+type __VLS_Props = {
+    landing?: string | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    landing: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/AdminShell.d.ts

@@ -3,9 +3,15 @@ declare function __VLS_template(): {
     slots: {
         brand?(_: {}): any;
         brand?(_: {}): any;
-        user?(_: {}): any;
-        user?(_: {}): any;
-        user?(_: {}): any;
+        user?(_: {
+            expanded: boolean;
+        }): any;
+        user?(_: {
+            expanded: boolean;
+        }): any;
+        user?(_: {
+            expanded: boolean;
+        }): any;
         nav?(_: {
             collapsed: boolean;
         }): any;

package/dist/BackButton.d.ts

@@ -0,0 +1,25 @@
+import { ActionSize } from '@webx-ui/core';
+import { RouteLocationRaw } from 'vue-router';
+/**
+ * The way out of an editor, said plainly.
+ *
+ * A trail of breadcrumbs is where the reader *is*; it is not a way out, and on a phone it is
+ * four words in the smallest type on the screen. Every screen that opens one record — a page,
+ * a block, a rule — ends up needing the same control, so it is one control rather than each
+ * editor's own arrow.
+ *
+ * An arrow and nothing else: the label is the tooltip, because the name of the section it
+ * returns to is already written next to it in the trail, and twice is noise.
+ */
+type __VLS_Props = {
+    /** Where it leads — the section's list, normally. */
+    to: RouteLocationRaw;
+    /** What the tooltip says. Defaults to the panel's own word for it. */
+    label?: string;
+    size?: ActionSize;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: ActionSize;
+    label: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/HelpButton.d.ts

@@ -0,0 +1,31 @@
+import { ActionSize } from '@webx-ui/core';
+/**
+ * A `?` beside something that needs explaining, and the page of explanation behind it.
+ *
+ * The text is Markdown and comes from wherever the caller keeps it — normally a `help` group
+ * in a module's `lang` files, which means it is translated in the same place as everything
+ * else and is already on the client with the rest of the dictionary. No request, no second
+ * store, and a language nobody has translated falls back to the site's own the way every
+ * other line does.
+ *
+ * Keeping it as Markdown rather than as a screen of components is what lets the same words
+ * serve an agent: a module can hand the identical text to MCP as `text/markdown`, and then
+ * there is one explanation of a thing rather than two that drift.
+ */
+type __VLS_Props = {
+    /** The page, in Markdown. */
+    body: string;
+    /** Heading of the dialog. Defaults to the panel's own word for it. */
+    title?: string;
+    /** Tooltip of the button. Defaults to the heading. */
+    label?: string;
+    size?: ActionSize;
+    width?: number | string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    size: ActionSize;
+    label: string;
+    width: number | string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/NotesFeed.d.ts

@@ -0,0 +1,30 @@
+/**
+ * What one administrator wrote on a record for the next one.
+ *
+ * Deliberately a component of the frame and not of any section. The first place that wanted
+ * one was the inbox, the next will be an order and the one after that a client, and three
+ * copies of "who may write here, who may edit what they wrote" is two copies too many — so the
+ * feed, its address and its rules live here, and a section only says which record it is about.
+ *
+ * Nothing is drawn while the reader may not write: the server refuses either way, and a box
+ * that posts a 403 is worse than no box. Whether they may is the section's answer, because it
+ * is the section's permission (`can`).
+ */
+type __VLS_Props = {
+    /** The alias the server registered the model under — never a class name. */
+    type: string;
+    id: number | string;
+    /** Whether this reader may write and edit their own. */
+    can?: boolean;
+    /** Heading above the feed; the panel's own word for it by default. */
+    title?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: (() => any) | undefined;
+}>, {
+    title: string;
+    can: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/RenameButton.d.ts

@@ -0,0 +1,163 @@
+import { nextTick } from 'vue';
+import { ActionSize } from '@webx-ui/core';
+/**
+ * Renaming, made an act rather than a side effect.
+ *
+ * A heading that is quietly an `<input>` reads as a heading: nothing says it can be typed in,
+ * and the reader finds out by accident — or never. Worse, it is bound straight to the record,
+ * so a stray keystroke on what looks like a title is a rename nobody asked for.
+ *
+ * So the name is text, with a pencil beside it. The pencil opens a small form: one field, one
+ * button, and nothing changes until that button is pressed. Escape and a click outside leave
+ * the name as it was.
+ */
+type __VLS_Props = {
+    /** What is being renamed. Only written back when the form is submitted. */
+    name?: string;
+    /** Heading of the form, and the pencil's tooltip. Defaults to the panel's own word. */
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: ActionSize;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    rename: (name: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRename?: ((name: string) => any) | undefined;
+}>, {
+    size: ActionSize;
+    label: string;
+    placeholder: string;
+    name: string;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    field: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: import('@webx-ui/core').InputModelValue;
+            readonly id?: string | undefined;
+            readonly type?: import('@webx-ui/core').InputNativeType | undefined;
+            readonly size?: import('@webx-ui/core').InputSize | undefined;
+            readonly status?: import('@webx-ui/core').InputStatus | undefined;
+            readonly placeholder?: string | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly maxlength?: number | undefined;
+            readonly showCount?: boolean | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly ariaLabel?: string | undefined;
+            readonly localized?: boolean | undefined;
+            readonly onChange?: ((value: string) => any) | undefined | undefined;
+            readonly "onUpdate:modelValue"?: ((value: import('@webx-ui/core').InputModelValue) => any) | undefined | undefined;
+            readonly onInput?: ((value: string) => any) | undefined | undefined;
+            readonly onClear?: (() => any) | undefined | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined | undefined;
+            readonly onFocus?: ((event: FocusEvent) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            inputRef: HTMLInputElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", value: string) => void) & ((event: "clear") => void) & ((event: "blur", event: FocusEvent) => void) & ((event: "change", value: string) => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "update:modelValue", value: import('@webx-ui/core').InputModelValue) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: import('@webx-ui/core').InputModelValue;
+        } & import('@webx-ui/core').InputProps> & Readonly<{
+            onChange?: ((value: string) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('@webx-ui/core').InputModelValue) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+        }>, {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void | undefined;
+            input: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            change: (value: string) => any;
+            "update:modelValue": (value: import('@webx-ui/core').InputModelValue) => any;
+            input: (value: string) => any;
+            clear: () => any;
+            blur: (event: FocusEvent) => any;
+            focus: (event: FocusEvent) => any;
+        }, string, {
+            size: import('@webx-ui/core').InputSize;
+            disabled: boolean;
+            type: import('@webx-ui/core').InputNativeType;
+            placeholder: string;
+            ariaLabel: string;
+            clearable: boolean;
+            status: import('@webx-ui/core').InputStatus;
+            id: string;
+            readonly: boolean;
+            autocomplete: string;
+            maxlength: number;
+            showCount: boolean;
+            localized: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        size: import('@webx-ui/core').InputSize;
+        disabled: boolean;
+        type: import('@webx-ui/core').InputNativeType;
+        placeholder: string;
+        ariaLabel: string;
+        clearable: boolean;
+        status: import('@webx-ui/core').InputStatus;
+        id: string;
+        readonly: boolean;
+        autocomplete: string;
+        maxlength: number;
+        showCount: boolean;
+        localized: boolean;
+    }> & Omit<Readonly<{
+        modelValue?: import('@webx-ui/core').InputModelValue;
+    } & import('@webx-ui/core').InputProps> & Readonly<{
+        onChange?: ((value: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('@webx-ui/core').InputModelValue) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+    }>, "type" | "size" | "ariaLabel" | "input" | "select" | "placeholder" | "id" | "status" | "localized" | "blur" | "focus" | "disabled" | "readonly" | "clearable" | "maxlength" | "showCount" | "autocomplete"> & {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void | undefined;
+        input: HTMLInputElement | null;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prefix?(_: {}): any;
+            suffix?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+export default _default;

package/dist/admin.d.ts

@@ -26,6 +26,15 @@ export interface AdminContext {
     readonly types: TypeRegistry;
     /** Ask the server what the panel is and who is signed in again. */
     reload(): Promise<void>;
+    /**
+     * Fetch the manifest again and adopt it, without the panel going through `loading` — so the
+     * chrome changes under whoever is looking at it instead of being replaced by a spinner.
+     *
+     * For a screen that has just saved something the manifest reports: the branding, the name of
+     * the site, what a section is called. A failure is swallowed, because what it would cost is
+     * a working panel in exchange for a stale logo.
+     */
+    refreshManifest(): Promise<void>;
     /**
      * Draw the panel in another language: fetches that dictionary and remembers the choice for
      * the next visit. Storing it against the administrator is an auth module's business — this

package/dist/index.d.ts

@@ -2,14 +2,21 @@ export { createAdmin, type Admin, type AdminPlugin, type CreateAdminOptions } fr
 export { createAdminContext, provideAdmin, useAdmin, adminKey, type AdminContext, type AdminState, } from './admin';
 export { createI18n, provideI18n, useI18n, useTranslate, i18nKey, type Dictionary, type I18n, type I18nState, type LocaleDescriptor, type Messages, type Translate, } from './i18n';
 export { adminMessages } from './messages';
+export { renderMarkdown } from './markdown';
 export { createDates, useDates, type DateLike, type Dates } from './dates';
 export { errorText, useErrorText } from './errors';
+export { createNotesApi, type EntityNote, type NoteAuthor, type NotesApi } from './notes';
 export { createHttp, readCookie, HttpError, type Http, type HttpOptions, type RequestOptions, } from './http';
 export { adminTypes } from './screenTypes';
 export type { AdminModule, AdminStatus, AdminUser, Manifest, ManifestModule, NavEntry, RowAction, } from './types';
 export { default as AdminShell } from './AdminShell';
 export { default as AdminNav } from './AdminNav';
+export { default as AdminLanding } from './AdminLanding';
 export { default as WxScreen } from './Screen';
 export { default as WxListScreen } from './ListScreen';
 export { default as WxRowMenu } from './RowMenu';
+export { default as WxBackButton } from './BackButton';
+export { default as WxRenameButton } from './RenameButton';
+export { default as WxHelpButton } from './HelpButton';
 export { default as WxDate } from './DateText';
+export { default as WxNotes } from './NotesFeed';