@chelone/vue 0.0.0-stage → 0.1.0

package/dist/components/admin/buttons/status-transition-button.vue.js

@@ -0,0 +1,172 @@
+import { defineComponent, inject, computed, ref, openBlock, createElementBlock, createVNode, unref, withCtx, normalizeClass, createTextVNode, toDisplayString, Fragment, renderList, createBlock, createCommentVNode } from "vue";
+import { getAllowedTransitions } from "@chelone/core";
+import { useCheloneNotifications } from "../../../context.js";
+import { useUpdate } from "../../../data/mutations.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { RecordContextKey } from "../../../record/record-context.js";
+import { useResourceContext } from "../../../resource-context.js";
+import _sfc_main$3 from "../../ui/button.vue.js";
+import _sfc_main$6 from "../feedback/confirm.vue.js";
+import { useMenuAccess } from "../layout/use-menu-access.js";
+import { ChevronDownIcon } from "./icons.js";
+import _sfc_main$1 from "../../ui/dropdown-menu/dropdown-menu.vue.js";
+import _sfc_main$2 from "../../ui/dropdown-menu/dropdown-menu-trigger.vue.js";
+import _sfc_main$4 from "../../ui/dropdown-menu/dropdown-menu-content.vue.js";
+import _sfc_main$5 from "../../ui/dropdown-menu/dropdown-menu-item.vue.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "inline-flex",
+  "data-slot": "status-transition"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "status-transition-button",
+  props: {
+    source: { default: "status" },
+    transitions: {},
+    guards: {},
+    labels: {},
+    resource: {},
+    record: {},
+    confirm: { type: Boolean, default: false },
+    mutationMode: { default: "pessimistic" },
+    class: {}
+  },
+  emits: ["transition"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const resource = useResourceContext(props);
+    const injectedRecord = inject(RecordContextKey, null);
+    const record = computed(() => props.record ?? injectedRecord?.value);
+    const translate = useTranslate();
+    const notifications = useCheloneNotifications();
+    const { canAccess, isPending: isAccessPending } = useMenuAccess(
+      computed(() => ({
+        action: "edit",
+        resource: resource ?? "",
+        record: record.value
+      }))
+    );
+    const update = useUpdate(resource ?? "", { mutationMode: props.mutationMode });
+    const transitionState = computed(
+      () => record.value ? getAllowedTransitions(record.value, {
+        source: props.source,
+        transitions: props.transitions,
+        guards: props.guards
+      }) : void 0
+    );
+    const show = computed(
+      () => !!resource && !!record.value && !isAccessPending.value && canAccess.value
+    );
+    const label = (state) => props.labels && Object.hasOwn(props.labels, state) ? props.labels[state] : state;
+    const pendingTarget = ref(null);
+    const confirmTitle = computed(
+      () => translate("chelone.status_transition.confirm_title", {
+        _: "Change status to {to}?",
+        to: label(pendingTarget.value ?? "")
+      })
+    );
+    const confirmContent = computed(
+      () => translate("chelone.status_transition.confirm_content", {
+        _: "The status changes from {from} to {to}.",
+        from: label(transitionState.value?.current ?? ""),
+        to: label(pendingTarget.value ?? "")
+      })
+    );
+    function onSelect(to) {
+      if (props.confirm) {
+        pendingTarget.value = to;
+        return;
+      }
+      void move(to);
+    }
+    async function move(to) {
+      const current = record.value;
+      if (!current) return;
+      const from = transitionState.value?.current ?? "";
+      try {
+        await update.mutateAsync({
+          id: current.id,
+          data: { [props.source]: to },
+          previousData: current
+        });
+      } catch {
+        notifications?.notify("chelone.notification.http_error", { type: "error" });
+        return;
+      }
+      if (props.mutationMode !== "undoable") {
+        notifications?.notify("chelone.notification.updated", {
+          type: "info",
+          messageArgs: { smart_count: 1 }
+        });
+      }
+      emit("transition", from, to, current);
+    }
+    async function onConfirm() {
+      const to = pendingTarget.value;
+      if (to === null) return;
+      try {
+        await move(to);
+      } finally {
+        pendingTarget.value = null;
+      }
+    }
+    return (_ctx, _cache) => {
+      return show.value ? (openBlock(), createElementBlock("span", _hoisted_1, [
+        createVNode(unref(_sfc_main$1), null, {
+          default: withCtx(() => [
+            createVNode(unref(_sfc_main$2), null, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$3, {
+                  type: "button",
+                  variant: "outline",
+                  disabled: !transitionState.value?.allowed.length || unref(update).isPending.value,
+                  class: normalizeClass(props.class),
+                  "aria-haspopup": "menu",
+                  "data-slot": "status-transition-trigger"
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(transitionState.value?.current ? label(transitionState.value.current) : unref(translate)("chelone.status_transition.change", { _: "Change status" })) + " ", 1),
+                    createVNode(unref(ChevronDownIcon))
+                  ]),
+                  _: 1
+                }, 8, ["disabled", "class"])
+              ]),
+              _: 1
+            }),
+            createVNode(unref(_sfc_main$4), null, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(transitionState.value?.allowed, (to) => {
+                  return openBlock(), createBlock(unref(_sfc_main$5), {
+                    key: to,
+                    "data-state-value": to,
+                    "data-slot": "status-transition-item",
+                    onSelect: ($event) => onSelect(to)
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(label(to)), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["data-state-value", "onSelect"]);
+                }), 128))
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        }),
+        createVNode(_sfc_main$6, {
+          "is-open": pendingTarget.value !== null,
+          loading: unref(update).isPending.value,
+          title: confirmTitle.value,
+          content: confirmContent.value,
+          onConfirm,
+          onClose: _cache[0] || (_cache[0] = ($event) => pendingTarget.value = null)
+        }, null, 8, ["is-open", "loading", "title", "content"])
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/status-transition-button2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./status-transition-button.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/toggle-filter-button.vue.d.ts

@@ -0,0 +1,26 @@
+import type { FilterPayload } from "@chelone/core";
+import type { ButtonSize } from "../../ui/button-variants.js";
+/** Props for {@link ToggleFilterButton}. */
+export interface ToggleFilterButtonProps {
+    /**
+     * Translated with itself as the fallback. The default slot replaces it with
+     * markup that renders as it is.
+     */
+    label?: string;
+    /** The filter this button sets, and removes again once the list holds it. */
+    value: FilterPayload;
+    size?: ButtonSize;
+    /** Extra CSS class appended to the button. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ToggleFilterButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToggleFilterButtonProps> & Readonly<{}>, {
+    size: ButtonSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/buttons/toggle-filter-button.vue.js

@@ -0,0 +1,43 @@
+import { defineComponent, computed, openBlock, createBlock, unref, normalizeClass, withCtx, renderSlot, createTextVNode, toDisplayString, createCommentVNode } from "vue";
+import { isFilterSelected, toggleFilterValue } from "@chelone/core";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { useListContext } from "../../../list/list-context.js";
+import _sfc_main$1 from "../../ui/button.vue.js";
+import { CircleXIcon } from "./icons.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "toggle-filter-button",
+  props: {
+    label: {},
+    value: {},
+    size: { default: "sm" },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const list = useListContext();
+    const translate = useTranslate();
+    const selected = computed(() => isFilterSelected(props.value, list.filter));
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        type: "button",
+        variant: selected.value ? "secondary" : "ghost",
+        size: props.size,
+        class: normalizeClass(props.class),
+        "aria-pressed": selected.value,
+        "data-slot": "toggle-filter-button",
+        onClick: _cache[0] || (_cache[0] = ($event) => unref(list).setFilters(unref(toggleFilterValue)(props.value, unref(list).filter)))
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(toDisplayString(props.label === void 0 ? "" : unref(translate)(props.label, { _: props.label })), 1)
+          ]),
+          selected.value ? (openBlock(), createBlock(unref(CircleXIcon), { key: 0 })) : createCommentVNode("", true)
+        ]),
+        _: 3
+      }, 8, ["variant", "size", "class", "aria-pressed"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/toggle-filter-button2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./toggle-filter-button.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/toolbar.vue.d.ts

@@ -0,0 +1,13 @@
+/** Props for {@link Toolbar}. */
+export interface ToolbarProps {
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ToolbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToolbarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/buttons/toolbar.vue.js

@@ -0,0 +1,32 @@
+import { defineComponent, useSlots, openBlock, createElementBlock, normalizeClass, unref, renderSlot, createVNode } from "vue";
+import { cn } from "../../../lib/utils.js";
+import _sfc_main$1 from "./save-button.vue.js";
+const _hoisted_1 = {
+  key: 1,
+  class: "flex flex-row gap-2 justify-between"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "toolbar",
+  props: {
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = useSlots();
+    const hasContent = () => slots.default != null;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "toolbar",
+        class: normalizeClass(unref(cn)("sticky bottom-0 pt-4 pb-4", props.class)),
+        "data-slot": "toolbar"
+      }, [
+        hasContent() ? renderSlot(_ctx.$slots, "default", { key: 0 }) : (openBlock(), createElementBlock("div", _hoisted_1, [
+          createVNode(_sfc_main$1)
+        ]))
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/toolbar2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./toolbar.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/update-button.vue.d.ts

@@ -0,0 +1,52 @@
+import type { LooseRecord, MutationMode } from "@chelone/core";
+/** Props for {@link UpdateButton}. */
+export interface UpdateButtonProps {
+    /** The fields to patch onto the record. */
+    data: Partial<LooseRecord>;
+    /**
+     * Read once at setup. `"undoable"` (default) patches the record now with an
+     * Undo notification and no dialog; the server call is deferred until the Undo
+     * window closes. `"pessimistic"` and `"optimistic"` ask for confirmation
+     * first, and `"optimistic"` closes the dialog on confirm.
+     */
+    mutationMode?: MutationMode;
+    /** Override the auto-translated label. */
+    label?: string;
+    /** Button variant. Default `"outline"`. */
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+    /** Override the ambient record. */
+    record?: LooseRecord;
+    /** Override the ambient `<Resource>`. */
+    resource?: string;
+    /** Confirmation-dialog title. Default `"ra.message.bulk_update_title"`. */
+    confirmTitle?: string;
+    /** Confirmation-dialog body copy. Default `"ra.message.bulk_update_content"`. */
+    confirmContent?: string;
+    /** `"warning"` tints the confirm button destructive. Default `"primary"`. */
+    confirmColor?: "primary" | "warning";
+    /** Extra CSS class appended to the button. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<UpdateButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (e?: MouseEvent | undefined) => any;
+    error: (error: unknown) => any;
+    success: (data: LooseRecord) => any;
+}, string, import("vue").PublicProps, Readonly<UpdateButtonProps> & Readonly<{
+    onClick?: ((e?: MouseEvent | undefined) => any) | undefined;
+    onError?: ((error: unknown) => any) | undefined;
+    onSuccess?: ((data: LooseRecord) => any) | undefined;
+}>, {
+    variant: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+    confirmColor: "primary" | "warning";
+    mutationMode: MutationMode;
+    confirmTitle: string;
+    confirmContent: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    icon?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/buttons/update-button.vue.js

@@ -0,0 +1,133 @@
+import { defineComponent, inject, computed, ref, openBlock, createElementBlock, Fragment, createBlock, normalizeClass, unref, withCtx, renderSlot, createVNode, createTextVNode, toDisplayString, createCommentVNode } from "vue";
+import { useCheloneNotifications } from "../../../context.js";
+import { useUpdate } from "../../../data/mutations.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { humanize, pluralize } from "../../../label/inflection.js";
+import { RecordContextKey } from "../../../record/record-context.js";
+import { useResourceContext } from "../../../resource-context.js";
+import _sfc_main$1 from "../../ui/button.vue.js";
+import _sfc_main$2 from "../feedback/confirm.vue.js";
+import { useMenuAccess } from "../layout/use-menu-access.js";
+import { RefreshCwIcon } from "./icons.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "update-button",
+  props: {
+    data: {},
+    mutationMode: { default: "undoable" },
+    label: {},
+    variant: { default: "outline" },
+    record: {},
+    resource: {},
+    confirmTitle: { default: "ra.message.bulk_update_title" },
+    confirmContent: { default: "ra.message.bulk_update_content" },
+    confirmColor: { default: "primary" },
+    class: {}
+  },
+  emits: ["click", "success", "error"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const resource = useResourceContext(props);
+    const injectedRecord = inject(RecordContextKey, null);
+    const record = computed(() => props.record ?? injectedRecord?.value);
+    const translate = useTranslate();
+    const notifications = useCheloneNotifications();
+    const { canAccess, isPending: isAccessPending } = useMenuAccess(
+      computed(() => ({
+        action: "edit",
+        resource: resource ?? "",
+        record: record.value
+      }))
+    );
+    const update = useUpdate(resource ?? "", { mutationMode: props.mutationMode });
+    const show = computed(
+      () => !!resource && record.value?.id != null && !isAccessPending.value && canAccess.value
+    );
+    const label = computed(() => {
+      if (props.label) return props.label;
+      const base = translate("ra.action.update", { _: "Update" });
+      return resource ? translate(`resources.${resource}.action.update`, { _: base }) : base;
+    });
+    const confirmOptions = computed(() => ({
+      smart_count: 1,
+      name: translate(`resources.${resource}.forcedCaseName`, {
+        smart_count: 1,
+        _: humanize(
+          translate(`resources.${resource}.name`, {
+            smart_count: 1,
+            _: resource ? pluralize(resource, 1) : ""
+          })
+        )
+      })
+    }));
+    const open = ref(false);
+    const params = () => ({
+      id: record.value?.id,
+      data: props.data,
+      previousData: record.value
+    });
+    function onClick(event) {
+      event.stopPropagation();
+      if (props.mutationMode !== "undoable") {
+        open.value = true;
+        return;
+      }
+      void update.mutateAsync(params());
+      emit("click", event);
+    }
+    async function onConfirm() {
+      const pending = update.mutateAsync(params());
+      if (props.mutationMode === "optimistic") open.value = false;
+      emit("click");
+      try {
+        const result = await pending;
+        notifications?.notify("chelone.notification.updated", {
+          type: "info",
+          messageArgs: { smart_count: 1 }
+        });
+        emit("success", result);
+      } catch (error) {
+        notifications?.notify("chelone.notification.http_error", { type: "error" });
+        emit("error", error);
+      } finally {
+        open.value = false;
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        show.value ? (openBlock(), createBlock(_sfc_main$1, {
+          key: 0,
+          type: "button",
+          variant: __props.variant,
+          disabled: unref(update).isPending.value,
+          class: normalizeClass(props.class),
+          "aria-label": label.value,
+          "data-slot": "update-button",
+          onClick
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "icon", {}, () => [
+              createVNode(unref(RefreshCwIcon))
+            ]),
+            createTextVNode(" " + toDisplayString(label.value), 1)
+          ]),
+          _: 3
+        }, 8, ["variant", "disabled", "class", "aria-label"])) : createCommentVNode("", true),
+        show.value ? (openBlock(), createBlock(_sfc_main$2, {
+          key: 1,
+          "is-open": open.value,
+          loading: unref(update).isPending.value,
+          title: __props.confirmTitle,
+          content: __props.confirmContent,
+          "confirm-color": __props.confirmColor,
+          "translate-options": confirmOptions.value,
+          onConfirm,
+          onClose: _cache[0] || (_cache[0] = ($event) => open.value = false)
+        }, null, 8, ["is-open", "loading", "title", "content", "confirm-color", "translate-options"])) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/buttons/update-button2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./update-button.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/common/application-updated-notification.vue.d.ts

@@ -0,0 +1,17 @@
+/** Props for {@link ApplicationUpdatedNotification}. */
+export interface ApplicationUpdatedNotificationProps {
+    message?: string;
+    buttonLabel?: string;
+    /** Alias for `message`. */
+    notificationText?: string;
+    /** Alias for `buttonLabel`. */
+    updateText?: string;
+    /** Extra CSS class merged after the default positioning classes. */
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<ApplicationUpdatedNotificationProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    reload: () => any;
+}, string, import("vue").PublicProps, Readonly<ApplicationUpdatedNotificationProps> & Readonly<{
+    onReload?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/common/application-updated-notification.vue.js

@@ -0,0 +1,63 @@
+import { defineComponent, getCurrentInstance, computed, openBlock, createBlock, unref, normalizeClass, withCtx, createVNode, createElementVNode, toDisplayString, createTextVNode } from "vue";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { cn } from "../../../lib/utils.js";
+import _sfc_main$1 from "../../ui/button.vue.js";
+import { Card } from "../../ui/card.js";
+import { SparklesIcon } from "./icons.js";
+const _hoisted_1 = { class: "text-sm" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "application-updated-notification",
+  props: {
+    message: {},
+    buttonLabel: {},
+    notificationText: {},
+    updateText: {},
+    class: {}
+  },
+  emits: ["reload"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const translate = useTranslate();
+    const instance = getCurrentInstance();
+    const messageText = computed(() => props.message ?? props.notificationText);
+    const buttonText = computed(() => props.buttonLabel ?? props.updateText);
+    const cardClass = computed(
+      () => cn(
+        "fixed bottom-4 left-1/2 z-50 -translate-x-1/2 flex-row items-center gap-3 px-4 py-3",
+        props.class
+      )
+    );
+    function onReload() {
+      const listeners = instance?.vnode.props;
+      if (listeners?.onReload || listeners?.onReloadOnce) emit("reload");
+      else window.location.reload();
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Card), {
+        role: "alert",
+        class: normalizeClass(cardClass.value)
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(SparklesIcon), { class: "size-4 shrink-0" }),
+          createElementVNode("span", _hoisted_1, toDisplayString(messageText.value ? unref(translate)(messageText.value, { _: messageText.value }) : unref(translate)("ra.notification.application_update_available", {
+            _: "A new version of the application is available"
+          })), 1),
+          createVNode(_sfc_main$1, {
+            size: "sm",
+            onClick: onReload
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(buttonText.value ? unref(translate)(buttonText.value, { _: buttonText.value }) : unref(translate)("ra.action.reload", { _: "Reload" })), 1)
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/common/application-updated-notification2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./application-updated-notification.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/common/check-for-application-update.vue.d.ts

@@ -0,0 +1,24 @@
+/** Props for {@link CheckForApplicationUpdate}. */
+export interface CheckForApplicationUpdateProps {
+    /** Page to fingerprint. Defaults to `${location.origin}/index.html`. */
+    url?: string;
+    /** Milliseconds between checks. Defaults to one hour. */
+    interval?: number;
+    /** Read at each check. `cache: "no-store"` always overrides it. */
+    fetchOptions?: RequestInit | (() => RequestInit);
+    /** Never fetch. Defaults to `true` outside production. */
+    disabled?: boolean;
+    /** Called once, when a new build is found. */
+    onNewVersionAvailable?: () => void;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CheckForApplicationUpdateProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CheckForApplicationUpdateProps> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    notification?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/common/check-for-application-update.vue.js

@@ -0,0 +1,31 @@
+import { defineComponent, toRef, unref, renderSlot, createVNode, createCommentVNode } from "vue";
+import { useCheckForApplicationUpdate } from "../../../data/use-check-for-application-update.js";
+import _sfc_main$1 from "./application-updated-notification.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "check-for-application-update",
+  props: {
+    url: {},
+    interval: {},
+    fetchOptions: {},
+    disabled: { type: Boolean, default: void 0 },
+    onNewVersionAvailable: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const hasNewVersion = useCheckForApplicationUpdate({
+      url: toRef(props, "url"),
+      interval: toRef(props, "interval"),
+      disabled: toRef(props, "disabled"),
+      fetchOptions: toRef(props, "fetchOptions"),
+      onNewVersionAvailable: toRef(props, "onNewVersionAvailable")
+    });
+    return (_ctx, _cache) => {
+      return unref(hasNewVersion) ? renderSlot(_ctx.$slots, "notification", { key: 0 }, () => [
+        createVNode(_sfc_main$1)
+      ]) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/common/check-for-application-update2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./check-for-application-update.vue.js";
+export {
+  _sfc_main as default
+};