@chelone/vue 0.0.0-stage → 0.1.0

package/dist/components/admin/inputs/use-choice-input.js

@@ -0,0 +1,42 @@
+import { computed } from "vue";
+import { useChoicesContext } from "../../../choices/choices-context.js";
+import { useChoices } from "../../../choices/use-choices.js";
+import { useGetRecordRepresentation } from "../../../label/use-get-record-representation.js";
+function useChoiceInput(options) {
+  const ctx = useChoicesContext({
+    choices: options.choices,
+    source: options.source
+  });
+  const source = ctx.source;
+  if (source === void 0) {
+    throw new Error(
+      `If you're not wrapping the ${options.componentName} inside a reference input, you must provide the source prop`
+    );
+  }
+  const isFromReference = ctx.isFromReference;
+  const resource = ctx.resource;
+  const getRecordRepresentation = useGetRecordRepresentation(resource);
+  const { getChoiceText, getChoiceValue, getDisableValue } = useChoices({
+    optionText: options.optionText ?? (isFromReference ? getRecordRepresentation : options.defaultOptionText),
+    optionValue: options.optionValue,
+    disableValue: options.disableValue,
+    translateChoice: options.translateChoice ?? !isFromReference
+  });
+  return {
+    source,
+    isFromReference,
+    resource,
+    // Computeds re-read the reference context's getters inside a tracking scope
+    // so the list stays live; for an inline context they read static fields.
+    allChoices: computed(() => ctx.allChoices ?? []),
+    isPending: computed(() => ctx.isPending),
+    fetchError: computed(() => ctx.error),
+    getChoiceText,
+    getChoiceValue,
+    getDisableValue,
+    setFilters: ctx.setFilters
+  };
+}
+export {
+  useChoiceInput
+};

package/dist/components/admin/inputs/webhook-endpoint-input.vue.d.ts

@@ -0,0 +1,34 @@
+import type { Validator } from "@chelone/core";
+/**
+ * Storage shape a `<WebhookEndpointInput>` edits. Mirrors the React twin's
+ * inlined type (the shadmin source imported it from a sibling field not yet
+ * ported). Re-exported for typing form values.
+ */
+export interface WebhookEndpoint {
+    url: string;
+    secret: string;
+    eventTypes: readonly string[];
+    lastDelivery?: {
+        status: "ok" | "failed" | "pending";
+        at: string;
+    };
+}
+/** Props for {@link WebhookEndpointInput}. */
+export interface WebhookEndpointInputProps {
+    source: string;
+    label?: string | false;
+    /** Available event-type strings to surface as checkboxes. */
+    eventTypes: readonly string[];
+    /** Optional test-ping handler. When set, renders the test-ping button. */
+    onTestPing?: (url: string, secret: string) => Promise<void> | void;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    isRequired?: boolean;
+    id?: string;
+    disabled?: boolean;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<WebhookEndpointInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<WebhookEndpointInputProps> & Readonly<{}>, {
+    label: string | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/inputs/webhook-endpoint-input.vue.js

@@ -0,0 +1,154 @@
+import { defineComponent, ref, computed, openBlock, createBlock, unref, normalizeClass, withCtx, createTextVNode, toDisplayString, createElementBlock, createCommentVNode, createElementVNode, createVNode, Fragment, renderList } from "vue";
+import { useInput } from "../../../form/use-input.js";
+import _sfc_main$3 from "../../ui/button.vue.js";
+import _sfc_main$2 from "../../ui/checkbox.vue.js";
+import { Field, FieldLabel, FieldError } from "../../ui/field.js";
+import _sfc_main$1 from "../../ui/input.vue.js";
+import _sfc_main$4 from "../common/validation-error.vue.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { class: "flex flex-col gap-3" };
+const _hoisted_3 = { class: "flex flex-wrap gap-3" };
+const _hoisted_4 = ["for"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "webhook-endpoint-input",
+  props: {
+    source: {},
+    label: { type: [String, Boolean], default: void 0 },
+    eventTypes: {},
+    onTestPing: {},
+    defaultValue: {},
+    validate: {},
+    isRequired: { type: Boolean },
+    id: {},
+    disabled: { type: Boolean },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const DEFAULT_VALUE = { url: "", secret: "", eventTypes: [] };
+    const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+      source: props.source,
+      defaultValue: props.defaultValue ?? DEFAULT_VALUE,
+      validate: props.validate,
+      isRequired: props.isRequired,
+      id: props.id,
+      // Keep the raw object/null so the render normalizes it (not coerced to `''`).
+      format: (raw) => raw
+    });
+    const pinging = ref(false);
+    const stored = computed(
+      () => value.value
+    );
+    const current = computed(() => ({
+      url: stored.value?.url ?? "",
+      secret: stored.value?.secret ?? "",
+      eventTypes: stored.value?.eventTypes ?? [],
+      lastDelivery: stored.value?.lastDelivery
+    }));
+    const invalid = computed(() => touched.value && error.value != null);
+    const labelText = computed(
+      () => props.label === false ? null : props.label ?? humanizeSource(props.source)
+    );
+    function update(patch) {
+      setValue({ ...current.value, ...patch });
+    }
+    function toggleEvent(event, checked) {
+      const set = new Set(current.value.eventTypes);
+      if (checked) set.add(event);
+      else set.delete(event);
+      update({ eventTypes: Array.from(set) });
+    }
+    async function handlePing() {
+      if (!props.onTestPing) return;
+      pinging.value = true;
+      try {
+        await props.onTestPing(current.value.url, current.value.secret);
+      } finally {
+        pinging.value = false;
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Field), {
+        class: normalizeClass(props.class),
+        "data-invalid": invalid.value
+      }, {
+        default: withCtx(() => [
+          labelText.value != null ? (openBlock(), createBlock(unref(FieldLabel), {
+            key: 0,
+            "html-for": unref(id)
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(labelText.value), 1),
+              unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["html-for"])) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_2, [
+            createVNode(_sfc_main$1, {
+              id: unref(id),
+              type: "url",
+              "data-webhook-url": "",
+              "model-value": current.value.url,
+              disabled: __props.disabled,
+              "aria-invalid": invalid.value,
+              placeholder: "https://example.com/webhook",
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => update({ url: $event })),
+              onBlur: unref(blur)
+            }, null, 8, ["id", "model-value", "disabled", "aria-invalid", "onBlur"]),
+            createVNode(_sfc_main$1, {
+              type: "password",
+              "data-webhook-secret": "",
+              "aria-label": "Signing secret",
+              "model-value": current.value.secret,
+              disabled: __props.disabled,
+              placeholder: "Signing secret",
+              "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => update({ secret: $event }))
+            }, null, 8, ["model-value", "disabled"]),
+            createElementVNode("div", _hoisted_3, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.eventTypes, (event) => {
+                return openBlock(), createElementBlock("label", {
+                  key: event,
+                  for: `webhook-event-${event}`,
+                  class: "flex items-center gap-2 font-mono text-sm"
+                }, [
+                  createVNode(_sfc_main$2, {
+                    id: `webhook-event-${event}`,
+                    "data-event-checkbox": "",
+                    "model-value": current.value.eventTypes.includes(event),
+                    disabled: __props.disabled,
+                    "onUpdate:modelValue": ($event) => toggleEvent(event, $event)
+                  }, null, 8, ["id", "model-value", "disabled", "onUpdate:modelValue"]),
+                  createTextVNode(" " + toDisplayString(event), 1)
+                ], 8, _hoisted_4);
+              }), 128))
+            ]),
+            __props.onTestPing ? (openBlock(), createBlock(_sfc_main$3, {
+              key: 0,
+              type: "button",
+              variant: "outline",
+              "data-test-ping-button": "",
+              disabled: __props.disabled || pinging.value || !current.value.url,
+              onClick: handlePing
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(pinging.value ? "Pinging…" : "Send test ping"), 1)
+              ]),
+              _: 1
+            }, 8, ["disabled"])) : createCommentVNode("", true)
+          ]),
+          invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+            default: withCtx(() => [
+              createVNode(_sfc_main$4, { error: unref(error) }, null, 8, ["error"])
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["class", "data-invalid"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/webhook-endpoint-input2.vue.js

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

package/dist/components/admin/layout/app-bar.vue.d.ts

@@ -0,0 +1,20 @@
+/** Props for {@link AppBar}. */
+export interface AppBarProps {
+    /** Extra class appended to the header element. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AppBarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AppBarProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    start?: (props: {}) => any;
+} & {
+    title?: (props: {}) => any;
+} & {
+    toolbar?: (props: {}) => any;
+} & {
+    'user-menu'?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/layout/app-bar.vue.js

@@ -0,0 +1,50 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, unref, renderSlot, createVNode, createElementVNode } from "vue";
+import { cn } from "../../../lib/utils.js";
+import _sfc_main$3 from "../buttons/locales-menu-button.vue.js";
+import _sfc_main$4 from "./theme-mode-toggle.vue.js";
+import _sfc_main$2 from "./title-portal.vue.js";
+import _sfc_main$5 from "./user-menu.vue.js";
+import _sfc_main$1 from "../../ui/sidebar/sidebar-trigger.vue.js";
+const _hoisted_1 = {
+  class: "flex min-w-0 flex-1 items-center",
+  "data-slot": "app-bar-title"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "app-bar",
+  props: {
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("header", {
+        class: normalizeClass(
+          unref(cn)(
+            "flex h-14 shrink-0 items-center gap-2 border-b px-4 md:h-12",
+            props.class
+          )
+        ),
+        "data-slot": "app-bar"
+      }, [
+        renderSlot(_ctx.$slots, "start", {}, () => [
+          createVNode(unref(_sfc_main$1))
+        ]),
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createVNode(_sfc_main$2)
+          ])
+        ]),
+        renderSlot(_ctx.$slots, "toolbar", {}, () => [
+          createVNode(_sfc_main$3),
+          createVNode(_sfc_main$4)
+        ]),
+        renderSlot(_ctx.$slots, "user-menu", {}, () => [
+          createVNode(_sfc_main$5)
+        ])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/app-bar2.vue.js

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

package/dist/components/admin/layout/app-sidebar.vue.d.ts

@@ -0,0 +1,23 @@
+/** Props for {@link AppSidebar}. */
+export interface AppSidebarProps {
+    /** Brand label in the sidebar header. Defaults to `"Chelone"`. */
+    brand?: string;
+    /**
+     * Where the brand links to, used as given (not prefixed with the basename).
+     * Defaults to the dashboard under the basename.
+     */
+    brandTo?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<AppSidebarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AppSidebarProps> & Readonly<{}>, {
+    brand: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    'brand-icon'?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/layout/app-sidebar.vue.js

@@ -0,0 +1,81 @@
+import { defineComponent, computed, openBlock, createBlock, unref, withCtx, createVNode, renderSlot, createElementVNode, toDisplayString } from "vue";
+import { RouterLink } from "vue-router";
+import _sfc_main$3 from "./menu.vue.js";
+import { useBasename } from "../../../router/adapter.js";
+import _sfc_main$1 from "../../ui/sidebar/sidebar.vue.js";
+import { SidebarHeader, SidebarMenu, SidebarMenuItem, SidebarContent, SidebarFooter } from "../../ui/sidebar/sidebar-parts.js";
+import _sfc_main$2 from "../../ui/sidebar/sidebar-menu-button.vue.js";
+const _hoisted_1 = { class: "text-base font-semibold" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "app-sidebar",
+  props: {
+    brand: { default: "Chelone" },
+    brandTo: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const basename = useBasename();
+    const to = computed(() => props.brandTo ?? `${basename}/`);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), {
+        variant: "floating",
+        collapsible: "icon"
+      }, {
+        default: withCtx(() => [
+          createVNode(unref(SidebarHeader), null, {
+            default: withCtx(() => [
+              createVNode(unref(SidebarMenu), null, {
+                default: withCtx(() => [
+                  createVNode(unref(SidebarMenuItem), null, {
+                    default: withCtx(() => [
+                      createVNode(unref(_sfc_main$2), {
+                        as: unref(RouterLink),
+                        to: to.value,
+                        size: "lg"
+                      }, {
+                        default: withCtx(() => [
+                          renderSlot(_ctx.$slots, "brand-icon", {}, () => [
+                            _cache[0] || (_cache[0] = createElementVNode("svg", {
+                              viewBox: "0 0 24 24",
+                              fill: "none",
+                              stroke: "currentColor",
+                              "stroke-width": "2",
+                              "stroke-linecap": "round",
+                              "stroke-linejoin": "round",
+                              class: "size-5",
+                              "aria-hidden": "true"
+                            }, [
+                              createElementVNode("path", { d: "M14 11a2 2 0 1 1-4 0 4 4 0 0 1 8 0 6 6 0 0 1-12 0 8 8 0 0 1 16 0 10 10 0 1 1-20 0 11.93 11.93 0 0 1 2.42-7.22 2 2 0 1 1 3.16 2.44" })
+                            ], -1))
+                          ]),
+                          createElementVNode("span", _hoisted_1, toDisplayString(__props.brand), 1)
+                        ]),
+                        _: 3
+                      }, 8, ["as", "to"])
+                    ]),
+                    _: 3
+                  })
+                ]),
+                _: 3
+              })
+            ]),
+            _: 3
+          }),
+          createVNode(unref(SidebarContent), null, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default", {}, () => [
+                createVNode(_sfc_main$3)
+              ])
+            ]),
+            _: 3
+          }),
+          createVNode(unref(SidebarFooter))
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/layout/app-sidebar2.vue.js

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

package/dist/components/admin/layout/command-menu-content.vue.d.ts

@@ -0,0 +1,26 @@
+import type { CommandMenuAction } from "./command-menu-context.js";
+/** What `<CommandMenu>` hands its body: the resolved props and the live commands. */
+export interface CommandMenuContentProps {
+    resources?: string[];
+    searchFields: Record<string, string>;
+    perResourceLimit: number;
+    recentsLimit: number;
+    searchDebounceMs: number;
+    placeholder?: string;
+    /** Registered commands plus the `actions` prop, in order. */
+    commands: CommandMenuAction[];
+}
+declare const _default: import("vue").DefineComponent<CommandMenuContentProps & {
+    query: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    "update:query": (value: string) => any;
+    run: (action: CommandMenuAction) => any;
+}, string, import("vue").PublicProps, Readonly<CommandMenuContentProps & {
+    query: string;
+}> & Readonly<{
+    onClose?: (() => any) | undefined;
+    "onUpdate:query"?: ((value: string) => any) | undefined;
+    onRun?: ((action: CommandMenuAction) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;