@chelone/vue 0.0.0-stage → 0.1.0

package/dist/components/admin/guessers/guess-components.js

@@ -0,0 +1,46 @@
+import _sfc_main$e from "../fields/boolean-field.vue.js";
+import _sfc_main$d from "../fields/date-field.vue.js";
+import _sfc_main$h from "../fields/email-field.vue.js";
+import _sfc_main$f from "../fields/number-field.vue.js";
+import _sfc_main$9 from "../fields/reference-array-field.vue.js";
+import _sfc_main$a from "../fields/reference-field.vue.js";
+import _sfc_main$c from "../fields/select-field.vue.js";
+import _sfc_main$b from "../fields/text-array-field.vue.js";
+import _sfc_main$i from "../fields/text-field.vue.js";
+import _sfc_main$g from "../fields/url-field.vue.js";
+import _sfc_main$6 from "../inputs/boolean-input.vue.js";
+import _sfc_main$5 from "../inputs/date-input.vue.js";
+import _sfc_main$4 from "../inputs/date-time-input.vue.js";
+import _sfc_main$7 from "../inputs/number-input.vue.js";
+import _sfc_main from "../inputs/reference-array-input.vue.js";
+import _sfc_main$1 from "../inputs/reference-input.vue.js";
+import _sfc_main$3 from "../inputs/select-input.vue.js";
+import _sfc_main$2 from "../inputs/text-array-input.vue.js";
+import _sfc_main$8 from "../inputs/text-input.vue.js";
+const guessFieldComponents = {
+  TextField: _sfc_main$i,
+  EmailField: _sfc_main$h,
+  UrlField: _sfc_main$g,
+  NumberField: _sfc_main$f,
+  BooleanField: _sfc_main$e,
+  DateField: _sfc_main$d,
+  SelectField: _sfc_main$c,
+  TextArrayField: _sfc_main$b,
+  ReferenceField: _sfc_main$a,
+  ReferenceArrayField: _sfc_main$9
+};
+const guessInputComponents = {
+  TextInput: _sfc_main$8,
+  NumberInput: _sfc_main$7,
+  BooleanInput: _sfc_main$6,
+  DateInput: _sfc_main$5,
+  DateTimeInput: _sfc_main$4,
+  SelectInput: _sfc_main$3,
+  TextArrayInput: _sfc_main$2,
+  ReferenceInput: _sfc_main$1,
+  ReferenceArrayInput: _sfc_main
+};
+export {
+  guessFieldComponents,
+  guessInputComponents
+};

package/dist/components/admin/guessers/guessed-code.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The text a guesser prints for a developer to copy: a Vue SFC that spells out
+ * the view it just rendered. The Vue twin of `@chelone/react`'s printer, with
+ * the two differences the Vue API forces: a `<DataTableCol>` / `<RecordField>`
+ * wraps its field as a child, and a reference input takes no child.
+ */
+import type { FieldDescriptor } from "@chelone/core";
+export type GuessedView = "List" | "Edit" | "Show";
+/**
+ * Prints the SFC for `view` of `resource` and a `Skipped:` line for each field
+ * the guessers cannot map to a component.
+ */
+export declare function printGuessedView(view: GuessedView, resource: string, fields: FieldDescriptor[]): string;

package/dist/components/admin/guessers/guessed-code.js

@@ -0,0 +1,104 @@
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function literal(value) {
+  if (typeof value === "string") {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+    return `'${escaped}'`;
+  }
+  if (Array.isArray(value)) return `[${value.map(literal).join(", ")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).map(
+      ([key, entry]) => `${IDENTIFIER.test(key) ? key : literal(key)}: ${literal(entry)}`
+    );
+    return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
+  }
+  return String(value);
+}
+const attrText = (text) => text.replace(/&/g, "&").replace(/"/g, """);
+const bound = (name, value) => `:${name}="${attrText(literal(value))}"`;
+const sourceAttrs = (field, withLabel = true) => `source="${attrText(field.source)}"${withLabel && field.label !== void 0 ? ` label="${attrText(field.label)}"` : ""}`;
+function attrs(field, withFieldProps, withLabel = false) {
+  const parts = [sourceAttrs(field, withLabel)];
+  if (field.reference !== void 0) {
+    parts.push(`reference="${attrText(field.reference)}"`);
+  }
+  if (field.choices !== void 0) parts.push(bound("choices", field.choices));
+  if (withFieldProps) {
+    for (const [name, value] of Object.entries(field.fieldProps ?? {})) {
+      parts.push(bound(name, value));
+    }
+  }
+  return parts.join(" ");
+}
+const pascal = (resource) => {
+  const name = resource.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return /^[A-Za-z]/.test(name) ? name : `Resource${name}`;
+};
+const isSkipped = (field) => field.kind === "unsupported" || field.field === void 0;
+function printGuessedView(view, resource, fields) {
+  const used = /* @__PURE__ */ new Set();
+  const use = (name) => {
+    used.add(name);
+    return name;
+  };
+  const supported = fields.filter((field) => !isSkipped(field));
+  const lines = [];
+  if (view === "List") {
+    lines.push("  <List>", "    <DataTable>");
+    for (const field of supported) {
+      const col = use("DataTableCol");
+      if (field.kind === "text") {
+        lines.push(`      <${col} ${sourceAttrs(field)} />`);
+      } else {
+        const component = use(field.field);
+        lines.push(
+          `      <${col} ${sourceAttrs(field)}><${component} ${attrs(field, true)} /></${col}>`
+        );
+      }
+    }
+    lines.push("    </DataTable>", "  </List>");
+  } else if (view === "Edit") {
+    lines.push("  <Edit>");
+    for (const field of supported) {
+      if (field.primary || field.input === void 0) continue;
+      const label = field.input !== "ReferenceArrayInput";
+      lines.push(`    <${use(field.input)} ${attrs(field, false, label)} />`);
+    }
+    lines.push(`    <${use("Toolbar")} />`, "  </Edit>");
+  } else {
+    lines.push("  <Show>");
+    for (const field of supported) {
+      const wrapper = use("RecordField");
+      if (field.kind === "text") {
+        lines.push(`    <${wrapper} ${sourceAttrs(field)} />`);
+      } else {
+        const component = use(field.field);
+        lines.push(
+          `    <${wrapper} ${sourceAttrs(field)}><${component} ${attrs(field, true)} /></${wrapper}>`
+        );
+      }
+    }
+    lines.push("  </Show>");
+  }
+  use(view);
+  if (view === "List") use("DataTable");
+  const skipped = fields.filter(isSkipped).map(
+    (field) => `Skipped: ${field.source} (${field.reason ?? "no component"})`
+  );
+  return [
+    `Guessed ${view} for "${resource}":`,
+    "",
+    '<script setup lang="ts">',
+    `import { ${[...used].sort().join(", ")} } from "@chelone/vue";`,
+    "",
+    `defineOptions({ name: "${pascal(resource)}${view}" });`,
+    "<\/script>",
+    "",
+    "<template>",
+    ...lines,
+    "</template>",
+    ...skipped.length > 0 ? ["", ...skipped] : []
+  ].join("\n");
+}
+export {
+  printGuessedView
+};

package/dist/components/admin/guessers/guesser-empty.vue.d.ts

@@ -0,0 +1,21 @@
+/** Props for {@link GuesserEmpty}. */
+export interface GuesserEmptyProps {
+    /** Replaces the default title. Translated, with itself as the fallback. */
+    title?: string;
+    /** Replaces the default message. Translated, with itself as the fallback. */
+    message?: string;
+    /** The resource named in the default message. */
+    resource?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<GuesserEmptyProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GuesserEmptyProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** Replaces the title text. */
+    title?: () => unknown;
+    /** Replaces the message text. */
+    message?: () => unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/admin/guessers/guesser-empty.vue.js

@@ -0,0 +1,47 @@
+import { defineComponent, computed, openBlock, createElementBlock, createVNode, unref, createElementVNode, renderSlot, createTextVNode, toDisplayString } from "vue";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { FileQuestionIcon } from "./icons.js";
+const _hoisted_1 = { class: "flex flex-col items-center gap-3 p-8 text-center" };
+const _hoisted_2 = { class: "text-xl font-semibold" };
+const _hoisted_3 = { class: "text-sm text-muted-foreground" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "guesser-empty",
+  props: {
+    title: {},
+    message: {},
+    resource: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const translate = useTranslate();
+    const heading = computed(
+      () => props.title === void 0 ? translate("chelone.guesser.no_schema.title", {
+        _: "No schema registered"
+      }) : translate(props.title, { _: props.title })
+    );
+    const body = computed(
+      () => props.message === void 0 ? translate("chelone.guesser.no_schema.message", {
+        _: "Register a Zod schema for {resource} with defineResources so this page can be generated.",
+        resource: props.resource ?? "this resource"
+      }) : translate(props.message, { _: props.message })
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(unref(FileQuestionIcon), { class: "size-12 text-muted-foreground" }),
+        createElementVNode("h2", _hoisted_2, [
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createTextVNode(toDisplayString(heading.value), 1)
+          ])
+        ]),
+        createElementVNode("p", _hoisted_3, [
+          renderSlot(_ctx.$slots, "message", {}, () => [
+            createTextVNode(toDisplayString(body.value), 1)
+          ])
+        ])
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/guessers/guesser-empty2.vue.js

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

package/dist/components/admin/guessers/icons.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The glyph the guessers need, as a dependency-free functional component.
+ * `@chelone/vue` carries no icon library, so this renders an inline SVG with
+ * the lucide stroke recipe, as `feedback/icons.ts` does. The icon is
+ * decorative (`aria-hidden`); the heading beside it carries the text.
+ */
+import { type FunctionalComponent } from "vue";
+/** A page with a question mark: the `<GuesserEmpty>` icon. */
+export declare const FileQuestionIcon: FunctionalComponent<{
+    class?: string;
+}>;

package/dist/components/admin/guessers/icons.js

@@ -0,0 +1,24 @@
+import { h } from "vue";
+const FileQuestionIcon = (props) => h(
+  "svg",
+  {
+    class: props.class,
+    viewBox: "0 0 24 24",
+    width: "24",
+    height: "24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": "2",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    "aria-hidden": "true"
+  },
+  [
+    "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
+    "M12 17h.01",
+    "M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3"
+  ].map((d) => h("path", { d }))
+);
+export {
+  FileQuestionIcon
+};

package/dist/components/admin/guessers/list-guesser.vue.d.ts

@@ -0,0 +1,10 @@
+import type { ListProps } from "../view/list.vue.js";
+/** Props for {@link ListGuesser}. */
+export type ListGuesserProps = ListProps & {
+    /** Print the generated code to the console. On outside production. */
+    enableLog?: boolean;
+};
+declare const _default: import("vue").DefineComponent<ListGuesserProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ListGuesserProps> & Readonly<{}>, {
+    enableLog: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/guessers/list-guesser.vue.js

@@ -0,0 +1,90 @@
+import { defineComponent, computed, watchEffect, unref, openBlock, createBlock, withCtx, createVNode, createElementBlock, Fragment, renderList, resolveDynamicComponent, mergeProps, createCommentVNode } from "vue";
+import { useResourceContext } from "../../../resource-context.js";
+import _sfc_main$3 from "../list/data-table.vue.js";
+import _sfc_main$4 from "../list/data-table-col.vue.js";
+import _sfc_main$2 from "../view/list.vue.js";
+import { guessFieldComponents } from "./guess-components.js";
+import { printGuessedView } from "./guessed-code.js";
+import _sfc_main$1 from "./guesser-empty.vue.js";
+import { useGuessedResource } from "./use-guessed-resource.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "list-guesser",
+  props: {
+    resource: {},
+    perPage: {},
+    title: {},
+    enableLog: { type: Boolean, default: (typeof process !== "undefined" ? process.env?.NODE_ENV : void 0) !== "production" }
+  },
+  setup(__props) {
+    const props = __props;
+    const resource = props.resource ?? useResourceContext();
+    if (!resource) {
+      throw new Error(
+        "<ListGuesser>: no resource. Pass a `resource` prop or render inside a <Resource>."
+      );
+    }
+    const descriptor = useGuessedResource(resource);
+    const columns = computed(
+      () => (descriptor.value?.fields ?? []).flatMap((field) => {
+        if (field.kind === "unsupported" || field.field === void 0) return [];
+        if (field.kind === "text") return [{ field, fieldProps: {} }];
+        return [
+          {
+            field,
+            component: guessFieldComponents[field.field],
+            fieldProps: {
+              source: field.source,
+              ...field.fieldProps,
+              ...field.reference !== void 0 && { reference: field.reference },
+              ...field.choices !== void 0 && { choices: field.choices }
+            }
+          }
+        ];
+      })
+    );
+    let logged = false;
+    watchEffect(() => {
+      if (logged || !props.enableLog || !descriptor.value) return;
+      logged = true;
+      console.log(printGuessedView("List", resource, descriptor.value.fields));
+    });
+    return (_ctx, _cache) => {
+      return !unref(descriptor) ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 0,
+        resource: unref(resource)
+      }, null, 8, ["resource"])) : (openBlock(), createBlock(_sfc_main$2, {
+        key: 1,
+        resource: unref(resource),
+        "per-page": __props.perPage,
+        title: __props.title
+      }, {
+        default: withCtx(() => [
+          createVNode(_sfc_main$3, null, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(columns.value, (column) => {
+                return openBlock(), createBlock(_sfc_main$4, {
+                  key: column.field.source,
+                  source: column.field.source,
+                  label: column.field.label
+                }, {
+                  default: withCtx(() => [
+                    column.component ? (openBlock(), createBlock(resolveDynamicComponent(column.component), mergeProps({
+                      key: 0,
+                      ref_for: true
+                    }, column.fieldProps), null, 16)) : createCommentVNode("", true)
+                  ]),
+                  _: 2
+                }, 1032, ["source", "label"]);
+              }), 128))
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["resource", "per-page", "title"]));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/guessers/list-guesser2.vue.js

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

package/dist/components/admin/guessers/show-guesser.vue.d.ts

@@ -0,0 +1,10 @@
+import type { ShowProps } from "../view/show.vue.js";
+/** Props for {@link ShowGuesser}. */
+export type ShowGuesserProps = ShowProps & {
+    /** Print the generated code to the console. On outside production. */
+    enableLog?: boolean;
+};
+declare const _default: import("vue").DefineComponent<ShowGuesserProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ShowGuesserProps> & Readonly<{}>, {
+    enableLog: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/guessers/show-guesser.vue.js

@@ -0,0 +1,88 @@
+import { defineComponent, computed, watchEffect, unref, openBlock, createBlock, normalizeProps, mergeProps, withCtx, createElementBlock, Fragment, renderList, resolveDynamicComponent } from "vue";
+import { useResourceContext } from "../../../resource-context.js";
+import _sfc_main$3 from "../fields/record-field.vue.js";
+import _sfc_main$2 from "../view/show.vue.js";
+import { guessFieldComponents } from "./guess-components.js";
+import { printGuessedView } from "./guessed-code.js";
+import _sfc_main$1 from "./guesser-empty.vue.js";
+import { useGuessedResource } from "./use-guessed-resource.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "show-guesser",
+  props: {
+    resource: {},
+    id: {},
+    title: {},
+    enableLog: { type: Boolean, default: (typeof process !== "undefined" ? process.env?.NODE_ENV : void 0) !== "production" }
+  },
+  setup(__props) {
+    const props = __props;
+    const resource = props.resource ?? useResourceContext();
+    if (!resource) {
+      throw new Error(
+        "<ShowGuesser>: no resource. Pass a `resource` prop or render inside a <Resource>."
+      );
+    }
+    const descriptor = useGuessedResource(resource);
+    const rows = computed(
+      () => (descriptor.value?.fields ?? []).flatMap((field) => {
+        if (field.kind === "unsupported" || field.field === void 0) return [];
+        if (field.kind === "text") return [{ field, fieldProps: {} }];
+        return [
+          {
+            field,
+            component: guessFieldComponents[field.field],
+            fieldProps: {
+              source: field.source,
+              ...field.fieldProps,
+              ...field.reference !== void 0 && { reference: field.reference },
+              ...field.choices !== void 0 && { choices: field.choices }
+            }
+          }
+        ];
+      })
+    );
+    const showProps = computed(() => {
+      const { enableLog: _enableLog, ...rest } = props;
+      return { ...rest, resource };
+    });
+    let logged = false;
+    watchEffect(() => {
+      if (logged || !props.enableLog || !descriptor.value) return;
+      logged = true;
+      console.log(printGuessedView("Show", resource, descriptor.value.fields));
+    });
+    return (_ctx, _cache) => {
+      return !unref(descriptor) ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 0,
+        resource: unref(resource)
+      }, null, 8, ["resource"])) : (openBlock(), createBlock(_sfc_main$2, normalizeProps(mergeProps({ key: 1 }, showProps.value)), {
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(rows.value, (row) => {
+            return openBlock(), createElementBlock(Fragment, {
+              key: row.field.source
+            }, [
+              row.component ? (openBlock(), createBlock(_sfc_main$3, {
+                key: 0,
+                source: row.field.source,
+                label: row.field.label
+              }, {
+                default: withCtx(() => [
+                  (openBlock(), createBlock(resolveDynamicComponent(row.component), mergeProps({ ref_for: true }, row.fieldProps), null, 16))
+                ]),
+                _: 2
+              }, 1032, ["source", "label"])) : (openBlock(), createBlock(_sfc_main$3, {
+                key: 1,
+                source: row.field.source,
+                label: row.field.label
+              }, null, 8, ["source", "label"]))
+            ], 64);
+          }), 128))
+        ]),
+        _: 1
+      }, 16));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/guessers/show-guesser2.vue.js

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

package/dist/components/admin/guessers/use-guessed-resource.d.ts

@@ -0,0 +1,8 @@
+import { type ResourceDescriptor } from "@chelone/core";
+import { type ComputedRef, type MaybeRefOrGetter } from "vue";
+/**
+ * Describes the Zod schema registered for `resource`, or `undefined` when
+ * `<Admin>` has no `registry` prop or the resource has no schema. The guessers
+ * build their views from this, never from fetched records.
+ */
+export declare function useGuessedResource(resource: MaybeRefOrGetter<string>): ComputedRef<ResourceDescriptor | undefined>;

package/dist/components/admin/guessers/use-guessed-resource.js

@@ -0,0 +1,14 @@
+import { describeResource } from "@chelone/core";
+import { computed, toValue } from "vue";
+import { useCheloneContext } from "../../../context.js";
+function useGuessedResource(resource) {
+  const { resources } = useCheloneContext();
+  return computed(() => {
+    const name = toValue(resource);
+    const config = resources && Object.hasOwn(resources, name) ? resources[name] : void 0;
+    return describeResource(name, config);
+  });
+}
+export {
+  useGuessedResource
+};

package/dist/components/admin/inputs/api-key-input.vue.d.ts

@@ -0,0 +1,14 @@
+import type { LooseRecord } from "@chelone/core";
+/** Props for {@link ApiKeyInput}. */
+export interface ApiKeyInputProps {
+    /** Record field holding the API key. */
+    source: string;
+    /** Override resource. */
+    resource?: string;
+    /** Async side-effect on rotate. When provided, replaces the default update mutation. */
+    onRotate?: (record: LooseRecord) => Promise<void> | void;
+    /** Disable the button. */
+    disabled?: boolean;
+}
+declare const _default: import("vue").DefineComponent<ApiKeyInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ApiKeyInputProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/inputs/api-key-input.vue.js

@@ -0,0 +1,95 @@
+import { defineComponent, inject, computed, ref, openBlock, createElementBlock, createVNode, withCtx, createTextVNode, createElementVNode, toDisplayString, createCommentVNode } from "vue";
+import { useUpdate } from "../../../data/mutations.js";
+import { RecordContextKey } from "../../../record/record-context.js";
+import { useResourceContext } from "../../../resource-context.js";
+import _sfc_main$1 from "../../ui/button.vue.js";
+const _hoisted_1 = {
+  key: 0,
+  role: "alertdialog",
+  "aria-modal": "true",
+  class: "mt-2 rounded-md border border-input bg-background p-4"
+};
+const _hoisted_2 = { class: "mt-3 flex justify-end gap-2" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "api-key-input",
+  props: {
+    source: {},
+    resource: {},
+    onRotate: { type: Function },
+    disabled: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const recordRef = inject(RecordContextKey, void 0);
+    const record = computed(() => recordRef?.value);
+    const resource = useResourceContext({ resource: props.resource });
+    const update = useUpdate(resource ?? "");
+    const open = ref(false);
+    const pending = ref(false);
+    async function handleRotate() {
+      pending.value = true;
+      try {
+        const rec = record.value;
+        if (props.onRotate && rec) {
+          await props.onRotate(rec);
+        } else if (rec && resource) {
+          await update.mutateAsync({
+            id: rec.id,
+            data: { [props.source]: null },
+            previousData: rec
+          });
+        }
+      } finally {
+        pending.value = false;
+        open.value = false;
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        createVNode(_sfc_main$1, {
+          type: "button",
+          variant: "outline",
+          "data-rotate-button": "",
+          disabled: __props.disabled,
+          onClick: _cache[0] || (_cache[0] = ($event) => open.value = true)
+        }, {
+          default: withCtx(() => [..._cache[2] || (_cache[2] = [
+            createTextVNode(" Rotate ", -1)
+          ])]),
+          _: 1
+        }, 8, ["disabled"]),
+        open.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          _cache[4] || (_cache[4] = createElementVNode("p", { class: "font-semibold" }, "Rotate API key?", -1)),
+          _cache[5] || (_cache[5] = createElementVNode("p", { class: "text-sm text-muted-foreground" }, " Are you sure? The current key will be revoked immediately. Any integrations still using it will break until they're updated. ", -1)),
+          createElementVNode("div", _hoisted_2, [
+            createVNode(_sfc_main$1, {
+              type: "button",
+              variant: "outline",
+              "data-rotate-cancel": "",
+              onClick: _cache[1] || (_cache[1] = ($event) => open.value = false)
+            }, {
+              default: withCtx(() => [..._cache[3] || (_cache[3] = [
+                createTextVNode(" Cancel ", -1)
+              ])]),
+              _: 1
+            }),
+            createVNode(_sfc_main$1, {
+              type: "button",
+              "data-rotate-confirm": "",
+              disabled: pending.value,
+              onClick: handleRotate
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(pending.value ? "Rotating…" : "Rotate"), 1)
+              ]),
+              _: 1
+            }, 8, ["disabled"])
+          ])
+        ])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/api-key-input2.vue.js

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