@chelone/vue 0.4.0 → 0.6.0

package/dist/create-resource-components.d.ts

@@ -27,7 +27,8 @@
  * directly; their `source` keeps the registered union, or a plain string when
  * nothing is registered.
  */
-import type { RecordOf, RegisteredResourceName, RegisteredResources, ResourceMap, SourceProp } from "@chelone/core";
+import type { RecordOf, RegisteredResourceName, RegisteredResources, ResourceMap, SourceProp, SourceValue } from "@chelone/core";
+import { type VNode } from "vue";
 import Create from "./components/admin/view/create.vue.js";
 import Edit from "./components/admin/view/edit.vue.js";
 import List from "./components/admin/view/list.vue.js";
@@ -259,7 +260,29 @@ declare const sourceMembers: {
             }) => any;
         };
     });
-    SelectField: import("vue").DefineComponent<import("./index.js").SelectFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").SelectFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    SelectField: <TChoice extends import("./index.js").ChoiceRecord = import("./index.js").ChoiceRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        attrs: any;
+        emit: {};
+        slots: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            source: SourceProp;
+            record?: import("@chelone/core").LooseRecord | undefined;
+            defaultValue?: unknown;
+            empty?: string | undefined;
+            choices?: readonly TChoice[] | undefined;
+            optionValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            optionText?: import("./index.js").OptionText<TChoice> | undefined;
+            translateChoice?: boolean | undefined;
+            class?: string | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {};
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
     SubscriptionPlanField: import("vue").DefineComponent<import("./index.js").SubscriptionPlanFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").SubscriptionPlanFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
     TextArrayField: import("vue").DefineComponent<import("./index.js").TextArrayFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").TextArrayFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
     TextField: import("vue").DefineComponent<import("./index.js").TextFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").TextFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
@@ -438,12 +461,34 @@ declare const sourceMembers: {
     BooleanInput: import("vue").DefineComponent<import("./index.js").BooleanInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").BooleanInputProps> & Readonly<{}>, {
         label: string | false;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-    CheckboxGroupInput: import("vue").DefineComponent<import("./index.js").CheckboxGroupInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").CheckboxGroupInputProps> & Readonly<{}>, {
-        label: string | false;
-        optionValue: string;
-        row: boolean;
-        disableValue: string;
-    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    CheckboxGroupInput: <TChoice extends import("./index.js").ChoiceRecord = import("./index.js").ChoiceRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        attrs: any;
+        emit: {};
+        slots: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            row?: boolean | undefined;
+            source?: string | undefined;
+            choices?: readonly (string | TChoice)[] | undefined;
+            optionText?: import("./index.js").OptionText<TChoice> | undefined;
+            optionValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            disableValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            translateChoice?: boolean | undefined;
+            label?: string | false | undefined;
+            helperText?: string | undefined;
+            defaultValue?: unknown;
+            validate?: (import("@chelone/core").Validator | readonly import("@chelone/core").Validator[]) | undefined;
+            disabled?: boolean | undefined;
+            readonly?: boolean | undefined;
+            class?: string | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {};
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
     ColorInput: import("vue").DefineComponent<import("./index.js").ColorInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").ColorInputProps> & Readonly<{}>, {
         label: string | false;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
@@ -454,9 +499,34 @@ declare const sourceMembers: {
         label: string | false;
         storeAsMinorUnits: boolean;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-    DatagridInput: import("vue").DefineComponent<import("./index.js").DatagridInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").DatagridInputProps> & Readonly<{}>, {
-        optionValue: string;
-    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    DatagridInput: <TChoice extends import("./index.js").ChoiceRecord = import("./index.js").ChoiceRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        attrs: any;
+        emit: {};
+        slots: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            optionLabel?: string | undefined;
+            source?: string | undefined;
+            choices?: readonly (string | TChoice)[] | undefined;
+            optionText?: import("./index.js").OptionText<TChoice> | undefined;
+            optionValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            disableValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            translateChoice?: boolean | undefined;
+            label?: string | false | undefined;
+            helperText?: string | undefined;
+            defaultValue?: unknown;
+            validate?: (import("@chelone/core").Validator | readonly import("@chelone/core").Validator[]) | undefined;
+            disabled?: boolean | undefined;
+            readonly?: boolean | undefined;
+            class?: string | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {};
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
     DateInput: import("vue").DefineComponent<import("./index.js").DateInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").DateInputProps> & Readonly<{}>, {
         label: string | false;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
@@ -577,12 +647,34 @@ declare const sourceMembers: {
         label: string | false;
         defaultCountry: import("libphonenumber-js").CountryCode;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-    RadioButtonGroupInput: import("vue").DefineComponent<import("./index.js").RadioButtonGroupInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").RadioButtonGroupInputProps> & Readonly<{}>, {
-        label: string | false;
-        optionValue: string;
-        row: boolean;
-        disableValue: string;
-    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    RadioButtonGroupInput: <TChoice extends import("./index.js").ChoiceRecord = import("./index.js").ChoiceRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        attrs: any;
+        emit: {};
+        slots: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            row?: boolean | undefined;
+            source?: string | undefined;
+            choices?: readonly (string | TChoice)[] | undefined;
+            optionText?: import("./index.js").OptionText<TChoice> | undefined;
+            optionValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            disableValue?: import("@chelone/core").SourcePath<TChoice> | undefined;
+            translateChoice?: boolean | undefined;
+            label?: string | false | undefined;
+            helperText?: string | undefined;
+            defaultValue?: unknown;
+            validate?: (import("@chelone/core").Validator | readonly import("@chelone/core").Validator[]) | undefined;
+            disabled?: boolean | undefined;
+            readonly?: boolean | undefined;
+            class?: string | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {};
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
     RatingInput: import("vue").DefineComponent<import("./index.js").RatingInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./index.js").RatingInputProps> & Readonly<{}>, {
         label: string | false;
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
@@ -707,6 +799,38 @@ type WithSource<P, TSource> = "source" extends keyof P ? Omit<P, "source"> & (Pa
 type Retyped<TComponent extends Ctor, TSource> = Pick<TComponent, keyof TComponent> & (new (...args: ConstructorParameters<TComponent>) => Omit<InstanceType<TComponent>, "$props"> & {
     $props: WithSource<InstanceType<TComponent>["$props"], TSource>;
 });
+/** The return type of an optional callback prop. */
+type CallbackResult<TCallback> = NonNullable<TCallback> extends (...args: never[]) => infer TResult ? TResult : never;
+/** The first parameter of an optional callback prop. */
+type CallbackParam<TCallback> = NonNullable<TCallback> extends (value: infer TValue, ...args: never[]) => unknown ? TValue : never;
+/**
+ * The `format`, `parse` and `transform` entries of `P` with `TValue` in place
+ * of the value they took or returned. Each stays optional and keeps the rest
+ * of its signature, and one `P` lacks is not added.
+ */
+type ValueEntries<P, TValue> = {
+    [K in Extract<keyof P, "format" | "transform">]?: (value: TValue) => CallbackResult<P[K]>;
+} & {
+    [K in Extract<keyof P, "parse">]?: (value: CallbackParam<P[K]>) => TValue;
+};
+/**
+ * A member whose props have a `format`, `parse` or `transform`: a generic
+ * function component over the literal `source`, so those callbacks take the
+ * value at it. Volar reads a function component's props off its first
+ * parameter and its slots off the second. `NoInfer` keeps `TPath` from being inferred back through
+ * `SourceValue` out of a callback's parameter, which overflows the type depth.
+ */
+type ValueMember<TComponent extends Ctor, TRecord> = <TPath extends SourceProp<TRecord>>(props: Omit<InstanceType<TComponent>["$props"], "source" | "format" | "parse" | "transform"> & (Partial<Pick<InstanceType<TComponent>["$props"], "source">> extends Pick<InstanceType<TComponent>["$props"], "source"> ? {
+    source?: TPath;
+} : {
+    source: TPath;
+}) & ValueEntries<InstanceType<TComponent>["$props"], NoInfer<SourceValue<TRecord, TPath>>>, ctx?: {
+    slots?: InstanceType<TComponent>["$slots"];
+}) => VNode;
+/** The member type: {@link ValueMember} when the props have a value callback, else {@link Retyped}. */
+type ResourceMember<TComponent extends Ctor, TRecord> = [
+    keyof InstanceType<TComponent>["$props"] & ("format" | "parse" | "transform")
+] extends [never] ? Retyped<TComponent, SourceProp<TRecord>> : ValueMember<TComponent, TRecord>;
 /**
  * A view with its `resource` prop removed. Templates are not strict about
  * undeclared attributes, so the prop stays as `never` to make
@@ -722,7 +846,7 @@ type BoundView<TComponent extends Ctor> = Pick<TComponent, keyof TComponent> & (
  * `TName`, and every field and input with `source` typed by `TName`'s record.
  */
 export type ResourceComponents<TResources extends ResourceMap, TName extends keyof TResources & string> = {
-    [K in keyof SourceMembers as SourceMembers[K] extends Ctor ? K : never]: Retyped<Extract<SourceMembers[K], Ctor>, SourceProp<RecordOf<TResources, TName>>>;
+    [K in keyof SourceMembers as SourceMembers[K] extends Ctor ? K : never]: ResourceMember<Extract<SourceMembers[K], Ctor>, RecordOf<TResources, TName>>;
 } & {
     Edit: BoundView<typeof Edit>;
     Create: BoundView<typeof Create>;

package/dist/data/create-chelone-hooks.d.ts

@@ -7,6 +7,7 @@
  */
 import type { GetListParams, GetManyParams, GetManyReferenceParams, GetOneParams, MutationModeOptions, ResourceMap } from "@chelone/core";
 import type { MaybeRefOrGetter } from "vue";
+import { type ListQueryOptions } from "./queries.js";
 type QueryOptions = {
     enabled?: MaybeRefOrGetter<boolean>;
 };
@@ -16,7 +17,7 @@ type QueryOptions = {
  *   hooks.useGetList('posts')  // data: Post[]; 'nope' rejects
  */
 export declare function createCheloneHooks<TResources extends ResourceMap>(): {
-    useGetList: <TName extends keyof TResources & string>(resource: TName, params?: MaybeRefOrGetter<GetListParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
+    useGetList: <TName extends keyof TResources & string>(resource: TName, params?: MaybeRefOrGetter<GetListParams>, options?: ListQueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
     useGetOne: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetOneParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>, Error>;
     useGetMany: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>[], Error>;
     useGetManyAggregate: <TName extends keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyParams>, options?: QueryOptions) => import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>[], Error>;

package/dist/data/queries.d.ts

@@ -36,13 +36,16 @@ export declare function useGetMany<TResources extends ResourceMap = ResourceMap,
 export declare function useGetManyAggregate<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyParams>, options?: {
     enabled?: MaybeRefOrGetter<boolean>;
 }): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").RecordOf<TResources, TName>[], Error>;
+/** `refetchInterval` is in ms; `0`, a negative number or `false` turns polling off. */
+export type ListQueryOptions = {
+    enabled?: MaybeRefOrGetter<boolean>;
+    refetchInterval?: MaybeRefOrGetter<number | false>;
+};
 /**
  * Fetch a page of records, reactively. `resource` may be a ref or getter, so a
  * changing resource re-keys the query.
  */
-export declare function useGetList<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: MaybeRefOrGetter<TName>, params?: MaybeRefOrGetter<GetListParams>, options?: {
-    enabled?: MaybeRefOrGetter<boolean>;
-}): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
+export declare function useGetList<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: MaybeRefOrGetter<TName>, params?: MaybeRefOrGetter<GetListParams>, options?: ListQueryOptions): import("@tanstack/vue-query").UseQueryReturnType<import("@chelone/core").GetListResult<import("@chelone/core").RecordOf<TResources, TName>>, Error>;
 /** Fetch the records whose `target` field equals `id`, reactively. */
 export declare function useGetManyReference<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, params: MaybeRefOrGetter<GetManyReferenceParams>, options?: {
     enabled?: MaybeRefOrGetter<boolean>;

package/dist/data/queries.js

@@ -32,10 +32,14 @@ function useGetManyAggregate(resource, params, options = {}) {
 function useGetList(resource, params = {}, options = {}) {
   const ctx = useCheloneContext();
   return useQuery(
-    computed(() => ({
-      ...getListOptions(ctx, toValue(resource), toValue(params)),
-      enabled: options.enabled === void 0 ? true : toValue(options.enabled)
-    }))
+    computed(() => {
+      const interval = toValue(options.refetchInterval);
+      return {
+        ...getListOptions(ctx, toValue(resource), toValue(params)),
+        enabled: options.enabled === void 0 ? true : toValue(options.enabled),
+        refetchInterval: typeof interval === "number" && interval > 0 ? interval : false
+      };
+    })
   );
 }
 function useGetManyReference(resource, params, options = {}) {