@antelopejs/dms 0.11.1 → 0.12.0

package/frontend-vue/layers/dms-ui/app/composables/chart/useChartFetch.ts

@@ -1,3 +1,4 @@
+import { isFunction } from "../../../../dms-core/app/utils/type-check";
 import {
   computed,
   getCurrentScope,
@@ -19,7 +20,6 @@ import {
 } from "../../build/utils/urlVariables";
 import { useRefreshTriggers } from "../../build/composables/blocks/useRefreshTriggers";
 import { readFetchNotFound } from "../../build/utils/fetchNotFound";
-import type { UseApiDataOptions } from "../../../../dms-core/app/composables/auth/useApiData";
 
 export interface UseChartFetchOptions<T> {
   /**
@@ -33,6 +33,7 @@ export interface UseChartFetchOptions<T> {
   fetchUrlMethod?: string;
   periodScope?: string;
   realtimeTopic?: string | string[];
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- This source is only JSON-stringified for equality; inference has no value and Vue WatchSource's generic owner deliberately permits any result.
   watchSource?: () => unknown;
   staticData?: T | null | (() => T | null);
 }
@@ -54,11 +55,7 @@ export interface UseChartFetchReturn<T> {
 }
 
 const DEBOUNCE_FRAME_MS = 180;
-// How long a card waits for its period scope to register before it stops
-// claiming to load. The selector registers the scope from its own lazily
-// loaded chunk, which on a slow network lands seconds after the card mounts:
-// a short grace would drop the card to its empty state ("No data") while the
-// scope is merely late. Only a scope no selector ever registers reaches it.
+
 export const PENDING_SCOPE_TIMEOUT_MS = 10_000;
 
 /** What a card asks for: its URL with its period, and the state it watches. */
@@ -75,7 +72,9 @@ function isSameRequest(left: ChartRequest, right: ChartRequest): boolean {
 function readStaticData<T>(
   source: UseChartFetchOptions<T>["staticData"],
 ): T | null {
-  if (typeof source === "function") return (source as () => T | null)();
+  if (isFunction(source)) {
+    return source();
+  }
   return source ?? null;
 }
 
@@ -92,7 +91,7 @@ function useResolvedFetchUrl<T>(
   return computed(() =>
     resolveUrlVariables(fetchUrl, {
       routeParams: options.routeParams?.(),
-      routeQuery: route.query as Record<string, unknown>,
+      routeQuery: route.query,
     }),
   );
 }
@@ -160,7 +159,7 @@ function useScopeWait(isWaiting: () => boolean): ComputedRef<boolean> {
 }
 
 function useDebouncedRefresh(
-  refresh: () => Promise<unknown>,
+  refresh: () => Promise<void>,
   isPending: () => boolean,
 ): () => Promise<void> {
   let timer: ReturnType<typeof setTimeout> | null = null;
@@ -185,8 +184,7 @@ function useDebouncedRefresh(
     waiting ??= new Promise<void>((resolve) => (resolveWaiting = resolve));
     timer = setTimeout(() => {
       timer = null;
-      // Cancellation ends one execution, not the refresh its callers await.
-      // Keep waiting while a replacement read is pending.
+
       void refresh().then(finishIfSettled, finishIfSettled);
     }, DEBOUNCE_FRAME_MS);
     return waiting;
@@ -220,22 +218,17 @@ export function useChartFetch<T>(
     };
   });
   const request = useScheduledRequest(target);
-  const loaded = useApiData<T>(() => request.current.value.url, {
-    method: options.fetchUrlMethod as UseApiDataOptions<T>["method"],
-    // A block never holds a navigation: it draws its skeleton meanwhile.
+  const loaded = useApiData<T | null>(() => request.current.value.url, {
+    method: options.fetchUrlMethod,
+
     lazy: true,
-    default: () => readStaticData(options.staticData) as T,
+    default: () => readStaticData(options.staticData),
     watch: [() => request.current.value.watched],
-    // Read again on its own triggers (realtime topic, page refresh, live
-    // gate): left out of the page's data refresh, which would read it twice.
+
     refreshOnPageRefresh: false,
   });
   const { data, status, error } = loaded;
-  // A 404 says what the block showed is gone (another tab deleted it, the
-  // URL now names another record): its last values must not stay on screen
-  // as if they still belonged to it. Any other failure of a read of the same
-  // request keeps them; a failure of a different (reactive) request shows
-  // none, as they belong to the record it replaced.
+
   watch(error, (failure) => {
     if (failure && readFetchNotFound(failure)) data.value = null;
   });
@@ -250,13 +243,9 @@ export function useChartFetch<T>(
       isWaitingForScope.value,
   );
   const refresh = async () => {
-    // A request that changed loads as it moves: joined, not started twice.
     await loaded.refresh(request.flush() ? { dedupe: "defer" } : undefined);
   };
-  // A realtime event or a page refresh (refreshPageBlocks) means the data
-  // behind unchanged inputs moved: read again once a burst holds still. The
-  // values on screen stay current until the new answer replaces them.
-  // `refreshPageBlocks()` waits for the read the burst ends with.
+
   useRefreshTriggers(
     options.realtimeTopic,
     useDebouncedRefresh(
@@ -264,17 +253,18 @@ export function useChartFetch<T>(
       () => status.value === "pending",
     ),
   );
-  return { data: data as Ref<T | null>, isLoading, error, refresh };
+  return { data, isLoading, error, refresh };
 }
 
 /** A block without `fetchUrl`: its `staticData`, followed as it changes. */
 function useStaticChartData<T>(
   options: UseChartFetchOptions<T>,
 ): UseChartFetchReturn<T> {
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Vue deeply unwraps static data, which need not remain T; retain the existing public ref contract and reactive behavior.
   const data = ref<T | null>(
     readStaticData(options.staticData),
   ) as Ref<T | null>;
-  if (typeof options.staticData === "function")
+  if (isFunction(options.staticData))
     watch(
       () => readStaticData(options.staticData),
       (next) => {

package/frontend-vue/layers/dms-ui/app/composables/chart/useChartTheme.ts

@@ -1,3 +1,5 @@
+import { isString } from "../../../../dms-core/app/utils/type-check";
+import type { ChartSeries } from "./types";
 const DEFAULT_COLOR_NAME = "primary";
 const SAFE_HEX_FALLBACK = "#7c3aed";
 const MUTED_FALLBACK = "#6b7280";
@@ -24,7 +26,12 @@ const DEFAULT_PALETTE = [
   "--dms-chart-5",
 ];
 
-const COLOR_NAME_TO_VAR: Record<string, string> = {
+type CssVariableName = Parameters<typeof readCssVariable>[0];
+
+const COLOR_NAME_TO_VAR: Record<
+  NonNullable<ChartSeries["color"]>,
+  CssVariableName
+> = {
   primary: "--ui-primary",
   secondary: "--ui-secondary",
   success: "--ui-success",
@@ -64,7 +71,7 @@ function toApexColor(color: string, fallback: string): string {
   if (!color || color === "transparent" || color === "rgba(0, 0, 0, 0)")
     return fallback;
   if (color.startsWith("rgb")) return color;
-  // Computed styles preserve OKLCH in modern browsers; Apex expects sRGB.
+
   const canvas = document.createElement("canvas");
   canvas.width = canvas.height = 1;
   const context = canvas.getContext("2d");
@@ -73,8 +80,7 @@ function toApexColor(color: string, fallback: string): string {
   context.fillRect(0, 0, 1, 1);
   const [red, green, blue, alpha] = context.getImageData(0, 0, 1, 1).data;
   if (!alpha) return fallback;
-  // Apex reads the alpha of an rgba() series colour as its fill opacity,
-  // overriding fill.opacity and gradient stops, so opaque colours stay rgb().
+
   if (alpha === COLOR_CHANNEL_MAX) return `rgb(${red}, ${green}, ${blue})`;
   return `rgba(${red}, ${green}, ${blue}, ${alpha / COLOR_CHANNEL_MAX})`;
 }
@@ -94,7 +100,7 @@ function probeCssColor(varName: string, fallback: string): string {
   const cached = colorProbeCache.get(cacheKey);
   if (cached) return cached;
   const probe = document.createElement("div");
-  // Background does not inherit body text when a token is missing or invalid.
+
   probe.style.backgroundColor = `var(${varName}, ${fallback})`;
   probe.style.position = "absolute";
   probe.style.visibility = "hidden";
@@ -131,11 +137,13 @@ export function resolveChartColor(value: string | undefined): string {
 }
 
 /** Resolve a supplied color list or the unchanged default semantic palette. */
-export function resolveChartColors(value: unknown): string[] {
+export function resolveChartColors(
+  value: Parameters<typeof isString>[0],
+): string[] {
   if (Array.isArray(value)) {
     return value.map((entry) => resolveChartColor(String(entry)));
   }
-  if (typeof value === "string") return [resolveChartColor(value)];
+  if (isString(value)) return [resolveChartColor(value)];
   return DEFAULT_PALETTE.map((name) => resolveChartColor(name));
 }
 

package/frontend-vue/layers/dms-ui/app/composables/confirm/types.ts

@@ -17,6 +17,7 @@ export type ConfirmBodyRender = () => VNodeChild;
 export type ConfirmImpact = ConfirmDialogImpact;
 
 /** The values the dialog's fields hold when the user confirms. */
+// oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Dialog fields are extensible plugin controls whose values are not restricted to JSON.
 export type ConfirmValues = Record<string, unknown>;
 
 /**
@@ -79,7 +80,7 @@ export interface ConfirmFromOptions {
    * Fill-ins of the URL's `{{row.X}}` tokens and of the dialog's texts (a
    * record's fields); the dialog's own `params` win in its texts.
    */
-  params?: Record<string, unknown>;
+  params?: ConfirmDialog["params"];
   /** What the dialog leaves out (a colour, an icon, a confirm label). */
   fallback?: Partial<ConfirmOptions>;
   /**

package/frontend-vue/layers/dms-ui/app/composables/containers/openDynamicContainer.ts

@@ -64,22 +64,19 @@ export function openDynamicContainer<Result, Options extends ContainerOptions>(
     },
   });
 
-  // The actual open is deferred past any closing menu; expose the eventual
-  // open() result through a stable promise and let close() abort a still-pending
-  // open (or resolve its result if it never opened).
   let opened = false;
   let resolveResult!: (value: Result) => void;
-  let rejectResult!: (reason?: unknown) => void;
+  let rejectResult!: Parameters<
+    ConstructorParameters<typeof Promise<Result>>[0]
+  >[1];
   const result = new Promise<Result>((resolve, reject) => {
     resolveResult = resolve;
     rejectResult = reject;
   });
   const cancelPendingOpen = openWhenMenusClosed(() => {
     opened = true;
-    // Forward both settle paths: a render error inside the mounted component
-    // must reject `result` rather than leave it pending (and unhandled), as the
-    // original `return instance.open()` did.
-    (instance.open() as Promise<Result>).then(resolveResult, rejectResult);
+
+    instance.open().then(resolveResult, rejectResult);
   });
 
   return {
@@ -89,10 +86,9 @@ export function openDynamicContainer<Result, Options extends ContainerOptions>(
       if (opened) {
         instance.close(value);
       } else {
-        // Closed before the deferred open fired: abort the pending open and tear
-        // down the eagerly-created overlay so it isn't orphaned in the manager.
         cancelPendingOpen();
         instance.close(value);
+        // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Closing before open historically resolves undefined when no value is passed, even for a non-optional Result.
         resolveResult(value as Result);
       }
     },

package/frontend-vue/layers/dms-ui/app/composables/containers/types.ts

@@ -1,4 +1,4 @@
-import type { Component } from "vue";
+import type { Component, ComponentPublicInstance } from "vue";
 import type { ModalSize } from "../../types/modal";
 import type { RowNavigation } from "../../types/row-navigation";
 
@@ -26,14 +26,14 @@ export interface ContainerOptions {
   title: string;
   description?: string;
   component: Component;
-  componentOptions?: Record<string, unknown>;
+  componentOptions?: ComponentPublicInstance["$attrs"];
   /**
    * Mounts the body component anew when it changes: a drawer stepping to
    * another row gives the component a fresh start on it.
    */
   componentKey?: string;
   headerComponent?: Component;
-  headerComponentOptions?: Record<string, unknown>;
+  headerComponentOptions?: ComponentPublicInstance["$attrs"];
   containerId?: string;
   /** Icon rendered in a 36px tinted well before the title. */
   icon?: string;
@@ -108,7 +108,7 @@ export interface DrawerRowHeader {
   /** Drawn under the position line, in the title's column (pills, hints). */
   component?: Component;
   /** Props passed to `component`. */
-  componentOptions?: Record<string, unknown>;
+  componentOptions?: ContainerOptions["componentOptions"];
 }
 
 /** Options accepted by {@link useModal}'s `open`. */

package/frontend-vue/layers/dms-ui/app/composables/containers/useDrawer.ts

@@ -1,4 +1,4 @@
-import { getCurrentInstance } from "vue";
+import { getCurrentInstance, type AppContext } from "vue";
 import DynamicDrawer from "../../build/components/containers/drawer/DynamicDrawer.vue";
 import DmsRowHeader from "../../build/components/containers/row/RowHeader.vue";
 import { drawerRowHeaderProps } from "../../build/components/containers/row/drawerRowHeader";
@@ -18,12 +18,12 @@ const DRAWER_ID_PREFIX = "drawer";
 /** What `useDrawer` hands the drawer besides its options. */
 interface DrawerCallerContext {
   /** The provides of the component that called `useDrawer` (see DynamicDrawer). */
-  callerProvides?: object;
+  callerProvides?: AppContext["provides"];
 }
 
 /** The part of a component instance holding what it and its ancestors provide. */
 interface InstanceProvides {
-  provides?: object;
+  provides: AppContext["provides"];
 }
 
 /**
@@ -33,18 +33,15 @@ interface InstanceProvides {
  */
 export function useDrawer() {
   const overlay = useOverlay();
-  // The drawer mounts under the app's overlay provider, outside the caller's
-  // tree: it inherits what the caller provides, as a drawer written in the
-  // caller's template does. Read at each opening, as the caller may provide
-  // after calling `useDrawer`. Vue keeps them in the instance's `provides`,
-  // which its public types do not list.
+
+  // SAFETY: Vue initializes every component instance's hidden provides from its parent or app context.
   const caller = getCurrentInstance() as InstanceProvides | null;
 
   function open<Result = unknown>(
     options: DrawerOptions,
   ): DrawerInstance<Result> {
     const { rowHeader, ...containerOptions } = options;
-    // The row header follows the title and the row it was last patched with.
+
     let title = options.title;
     let header: DrawerRowHeader | undefined = rowHeader;
     const headerProps = () => header && drawerRowHeaderProps(header, title);
@@ -53,7 +50,7 @@ export function useDrawer() {
       DrawerOptions & DrawerCallerContext
     >(overlay, DynamicDrawer, DRAWER_ID_PREFIX, {
       ...containerOptions,
-      // The DMS's own drawers keep the app's provides only.
+
       callerProvides: DMS_OWN_DRAWER in options ? undefined : caller?.provides,
       ...(rowHeader && {
         headerComponent: DmsRowHeader,
@@ -65,7 +62,6 @@ export function useDrawer() {
         componentSizeKey(options.component),
     });
     if (!rowHeader) {
-      // Without a row header to update, a patch is a container's.
       return {
         ...instance,
         patch: ({ rowHeader: _rowHeader, ...patch }: DrawerPatch) =>

package/frontend-vue/layers/dms-ui/app/composables/form/types/field-saved.ts

@@ -1,11 +1,15 @@
 import type { InjectionKey } from "vue";
+import type { validateFormState } from "../../../build/composables/form/formValidation";
 
 /**
  * Makes `value` the saved value of the field `id`: a control whose value the
  * server already stored on its own (a rotated secret) is not a change left to
  * save, and "Discard" keeps it.
  */
-export type MarkFieldSaved = (id: string, value: unknown) => void;
+export type MarkFieldSaved = (
+  id: string,
+  value: Parameters<typeof validateFormState>[1][string],
+) => void;
 
 export const FORM_FIELD_SAVED_KEY: InjectionKey<MarkFieldSaved> =
   Symbol("form-field-saved");

package/frontend-vue/layers/dms-ui/app/composables/form/types/props.ts

@@ -1,4 +1,5 @@
 import type { FormFieldOrGroup, FormSection, FormSectionNav } from "./field";
+import type { validateFormState } from "../../../build/composables/form/formValidation";
 import type {
   FormKind,
   FormSaveMode,
@@ -50,11 +51,16 @@ export interface FormProps extends FormComponentProps {
   backTo?: string;
   successMessage?: string;
   errorMessage?: string;
+  // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Backend JSON schemas are accepted before conversion by jsonSchemaToZod; a parsed field-value contract would exclude schema keywords and extensions.
   schema?: Record<string, unknown>;
   watchActions?: WatchAction[];
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Success callbacks expose the raw server response and submitted data for application extensions; neither payload has a closed shared schema.
   onSuccessCallback?: (response?: unknown, data?: unknown) => void;
   fieldsOrientation?: "horizontal" | "vertical";
-  submitDefaults?: Record<string, unknown>;
+  submitDefaults?: Record<
+    string,
+    Parameters<typeof validateFormState>[1][string]
+  >;
   containerId?: string;
   redirectOnSuccess?: string;
   /** Field of the loaded row a page form names in the breadcrumb. */