@antelopejs/dms 0.11.1 → 0.12.1

package/frontend-vue/layers/dms-ui/app/build/composables/table/useTableConfigClipboard.ts

@@ -1,4 +1,5 @@
 import { injectLocal } from "@vueuse/core";
+import { isObject } from "#dms-core/app/utils/type-check";
 import type { ShallowRef } from "vue";
 import type {
   Data,
@@ -12,19 +13,18 @@ const TOAST_DURATION_MS = 3000;
 interface SerializedTableConfig {
   v: typeof CONFIG_VERSION;
   search?: string;
-  filters: unknown[];
+  filters: TableSharedData<Data>["columnFiltersState"]["value"];
   order: string[];
   visibility: Record<string, boolean>;
   pinning: { left?: string[]; right?: string[] };
-  sorting: unknown[];
+  sorting: TableSharedData<Data>["sortingState"]["value"];
   pagination: { pageIndex: number; pageSize: number };
   density?: TableDensity;
 }
 
 const isSerializedConfig = (value: unknown): value is SerializedTableConfig => {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value as { v?: unknown };
-  return candidate.v === CONFIG_VERSION;
+  if (!value || !isObject(value)) return false;
+  return value.v === CONFIG_VERSION;
 };
 
 const encodeConfig = (config: SerializedTableConfig): string => {
@@ -74,11 +74,11 @@ export const useTableConfigClipboard = <T extends Data>() => {
     if (!data) return;
 
     data.globalFilterState.value = config.search ?? "";
-    data.columnFiltersState.value = config.filters as never;
+    data.columnFiltersState.value = config.filters;
     data.columnOrderState.value = config.order;
     data.columnVisibilityState.value = config.visibility;
     data.columnPinningState.value = config.pinning;
-    data.sortingState.value = config.sorting as never;
+    data.sortingState.value = config.sorting;
     data.paginationState.value = config.pagination;
     if (config.density) data.densityState.value = config.density;
   };

package/frontend-vue/layers/dms-ui/app/build/composables/table/utils/archivedCount.ts

@@ -1,6 +1,6 @@
 type Translate = (
   key: string,
-  named: Record<string, unknown>,
+  named: { count: string },
   plural: number,
 ) => string;
 

package/frontend-vue/layers/dms-ui/app/build/composables/table/utils/clearTableFilters.ts

@@ -3,13 +3,6 @@ import type { PaginationState } from "@tanstack/vue-table";
 import type { TableFilter } from "../../../components/table/Table.vue";
 import { isFilterEffective } from "../../table-view/utils/tableQuery";
 
-// Everything that narrows a table's rows — filter chips (quick filters write
-// theirs) and the toolbar search — cleared in one go. The "clear all" actions
-// (empty state, filters row, filters popover) all go through
-// `clearTableFilters`.
-// Sort, page size, tab, display, group-by and the archive toggle are not
-// filters: they stay as they are.
-
 export interface TableNarrowingState {
   columnFilters: Ref<TableFilter[]>;
   /** The toolbar search text. */
@@ -36,7 +29,7 @@ export interface ClearableTableFilters {
   search: boolean;
 }
 
-const sameValue = (a: unknown, b: unknown): boolean =>
+const sameValue = (a: TableFilter["value"], b: TableFilter["value"]): boolean =>
   JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
 
 /**

package/frontend-vue/layers/dms-ui/app/build/composables/table/utils/filterEditorValue.ts

@@ -2,12 +2,8 @@ import type {
   DataType,
   DataTypeFilterEditorValue,
 } from "#dms-core/app/composables/data-types/useDataType";
-
-// A view or tab declares its filter value as text (`TableViewTabFilter.value`),
-// the shape the query sends. The chip's value editor wants the value its
-// column's data type holds there ({@link DataType.filterEditorValue}). The
-// editor reads the converted value; the filter keeps its text until the user
-// edits it, so the query is unchanged.
+import type { TableFilter } from "../../../components/table/Table.vue";
+import { isString } from "#dms-core/app/utils/type-check";
 
 const LIST_SEPARATOR = ",";
 const BETWEEN_MODE = "is_between";
@@ -31,8 +27,8 @@ export const dateFilterEditorValue: DataTypeFilterEditorValue = (text, mode) =>
 export function filterEditorValue(
   dataType: Pick<DataType, "filterEditorValue"> | undefined,
   mode: string,
-  value: unknown,
-): unknown {
-  if (typeof value !== "string" || !dataType?.filterEditorValue) return value;
+  value: TableFilter["value"],
+): TableFilter["value"] {
+  if (!isString(value) || !dataType?.filterEditorValue) return value;
   return dataType.filterEditorValue(value, mode);
 }

package/frontend-vue/layers/dms-ui/app/build/composables/table/utils/formatFilterValue.ts

@@ -1,4 +1,5 @@
 import type { TableFilter } from "../../../components/table/Table.vue";
+import { isString } from "#dms-core/app/utils/type-check";
 
 interface FilterColumn {
   value: string;
@@ -7,8 +8,7 @@ interface FilterColumn {
 }
 
 const DAY_MS = 24 * 60 * 60 * 1000;
-// `{{now}}`, `{{now-7d}}`, `{{now+14d}}`: the tokens the server resolves in a
-// filter value (`filter-tokens.ts`), read here with the same rule.
+
 const NOW_TOKEN = /\{\{\s*now(?:\s*([+-])\s*(\d+)d)?\s*\}\}/g;
 const BETWEEN_MODE = "is_between";
 const BETWEEN_SEPARATOR = ",";
@@ -25,8 +25,8 @@ export function resolveNowTokens(value: string, now = Date.now()): string {
  * The value as the formatters read it: tokens resolved, and an `is_between`
  * bound pair written as text (`a,b`, the way the query sends it) split.
  */
-const readableValue = (filter: TableFilter): unknown => {
-  if (typeof filter.value !== "string") return filter.value;
+const readableValue = (filter: TableFilter): TableFilter["value"] => {
+  if (!isString(filter.value)) return filter.value;
   const value = resolveNowTokens(filter.value);
   if (filter.mode !== BETWEEN_MODE) return value;
   return value.split(BETWEEN_SEPARATOR).map((bound) => bound.trim());
@@ -49,14 +49,9 @@ export function formatFilterValue(
   const formatter =
     dataType.formatter[filter.mode] || dataType.formatter.default;
 
-  // A filter's value need not have the column's shape (a tag typed against
-  // a tags column, whose formatter draws a list): a formatter that writes
-  // nothing for it leaves the value as typed.
   try {
     const result = formatter(readableValue(filter), locale);
-    return typeof result === "string" && result !== ""
-      ? result
-      : String(filter.value);
+    return isString(result) && result !== "" ? result : String(filter.value);
   } catch {
     return String(filter.value);
   }

package/frontend-vue/layers/dms-ui/app/build/composables/table/utils/scrollEdges.ts

@@ -11,7 +11,6 @@ export interface HorizontalScroll {
   clientWidth: number;
 }
 
-// Sub-pixel widths leave a fraction of a pixel to scroll at either end.
 const EDGE_TOLERANCE_PX = 1;
 
 /**

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/displayRegistry.ts

@@ -18,8 +18,7 @@ export function useTableViewDisplayState() {
  */
 export function storeTableViewDisplay(entry: TableViewDisplay): void {
   const displays = useTableViewDisplayState();
-  // The registry is reactive state: a component stored in it would be made
-  // reactive too (Vue warns, and pays for it on every render).
+
   const display = entry.component
     ? { ...entry, component: markRaw(entry.component) }
     : entry;

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/registerDefaultFunctions.ts

@@ -13,6 +13,11 @@ export interface FormSuccessRoute {
   params?: Record<string, string>;
 }
 
+interface FormSuccessTarget {
+  path: string;
+  query?: RouteQuery;
+}
+
 /**
  * Where a page-mode form sends the user on submit: the page carrying the table
  * view. Its URL holds a `{{params.X}}` token per placeholder of that page's
@@ -22,14 +27,12 @@ export interface FormSuccessRoute {
 export function resolveFormSuccessTarget(
   { url, preserveQuery }: FormSuccessParams,
   route: FormSuccessRoute,
-): { path: string; query?: RouteQuery } {
+): FormSuccessTarget {
   const path = resolveLinkVariables(url, {
     routeParams: route.params,
     routeQuery: route.query,
   });
 
-  // Restore the filtered table view: carry back the query params the form
-  // was opened with (those declared in `queryParamFilters`).
   const query: RouteQuery = {};
   for (const key of preserveQuery ?? []) {
     if (route.query[key] !== undefined) {
@@ -37,7 +40,9 @@ export function resolveFormSuccessTarget(
     }
   }
 
-  return { path, ...(Object.keys(query).length > 0 ? { query } : {}) };
+  const target: FormSuccessTarget = { path };
+  if (Object.keys(query).length > 0) target.query = query;
+  return target;
 }
 
 export function registerDefaultFunctions() {
@@ -48,6 +53,7 @@ export function registerDefaultFunctions() {
   registerFunction(
     TableViewFunctions.CUSTOM_PAGE_FORM_SUCCESS,
     (event: CustomEvent) => {
+      // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- CustomEvent does not declare the function registry's params extension. Its owner supplies no typed event contract; validation would change malformed-event behavior.
       const { params } = event as CustomEvent & { params: FormSuccessParams };
 
       navigateDms(

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/tableRowActionBulkConfirm.ts

@@ -0,0 +1,227 @@
+import type {
+  TableRowActionsConfig,
+  TableRowActionServices,
+  BulkActionConfig,
+  ConfirmedRun,
+  DeleteRowsOptions,
+} from "./tableRowActionTypes";
+import { namesRowField } from "#dms-core/app/utils/url-interpolation";
+import {
+  isConfirmFrom,
+  type ActionConfirm,
+} from "#dms-core/app/types/confirm-dialog";
+import { bulkSelectionQuery, withQuery } from "../actions/bulkSelection";
+import {
+  bulkActionConfirm,
+  type ConfirmedBulkAction,
+} from "./utils/bulkActions";
+import type { ConfirmOptions } from "../../../composables/confirm/types";
+import { getItemId, DEFAULT_ROW_ID_KEY } from "./tableRowActionValues";
+import {
+  createTableRowBulkOutcomes,
+  type TableRowActionErrorHandler,
+} from "./tableRowActionBulkRequests";
+const declaredBulkConfirm = (
+  actionConfig: boolean | RowActionConfig | undefined,
+  ids: string[],
+): ActionConfirm | undefined => {
+  const declared = normalizeActionConfig(actionConfig).confirm;
+  if (!declared || !isConfirmFrom(declared)) return declared;
+  if (namesRowField(declared.from)) {
+    return ids.length === 1 ? declared : undefined;
+  }
+  return {
+    from: withQuery(
+      declared.from,
+      bulkSelectionQuery({ ids, count: ids.length }),
+    ),
+  };
+};
+const createConfirmRowFields = (config: TableRowActionsConfig) => {
+  const rowIdOf = (row: Data): string =>
+    String(getItemId(row, config.rowIdKey ?? DEFAULT_ROW_ID_KEY));
+
+  const findRowIn = (rows: Data[] | undefined, id: string) =>
+    rows?.find((row) => rowIdOf(row) === id);
+
+  const readRow = async (
+    id: string,
+    declared: ActionConfirm,
+  ): Promise<Data | undefined> => {
+    const getRow = config.rowNavigation?.getRow;
+    if (!getRow || isConfirmFrom(declared)) return undefined;
+    return getRow(id).catch(() => undefined);
+  };
+
+  /** The one row a dialog words: the caller's, the table's, else read. */
+  const findConfirmRow = async (
+    id: string,
+    declared: ActionConfirm,
+    rows?: Data[],
+  ): Promise<Data | undefined> =>
+    findRowIn(rows, id) ??
+    findRowIn(config.rowNavigation?.rows(), id) ??
+    (await readRow(id, declared));
+
+  /**
+   * What a fixed dialog words: the rows' count, and for one row its own
+   * fields too (`{name}`). The count wins a clash, it is what every bulk
+   * dialog may name.
+   */
+  const confirmRowFields = async (
+    ids: string[],
+    declared: ActionConfirm,
+    rows?: Data[],
+  ): Promise<Data> => {
+    const count = { count: ids.length };
+    const row =
+      ids.length === 1
+        ? await findConfirmRow(ids[0]!, declared, rows)
+        : undefined;
+    return row ? { ...row, ...count } : count;
+  };
+
+  return confirmRowFields;
+};
+const createBulkConfirmations = (
+  config: TableRowActionsConfig,
+  services: TableRowActionServices,
+  bulkActionRun: ReturnType<typeof createTableRowBulkOutcomes>["bulkActionRun"],
+) => {
+  const { confirmAction, confirm, t } = services;
+  const confirmRowFields = createConfirmRowFields(config);
+  /** Asks the declared confirmation of a bulk action, running it inside. */
+  const askDeclaredBulkConfirm = async (
+    declared: ActionConfirm,
+    ids: string[],
+    fallback: Partial<ConfirmOptions>,
+    run: ConfirmedRun,
+    rows?: Data[],
+  ): Promise<boolean> =>
+    confirmAction(declared, {
+      urlParams: {
+        id: ids[0],
+        [config.rowIdKey ?? DEFAULT_ROW_ID_KEY]: ids[0],
+      },
+      row: await confirmRowFields(ids, declared, rows),
+      fallback,
+      run,
+    });
+
+  /**
+   * Asks before a bulk action, then runs it from inside the dialog: the
+   * action's declared `confirm` (the server's own wording for a single row
+   * with `{ from }`), else the generic confirmation, toned for the action
+   * and counting the rows it reaches. Resolves whether rows went (false when
+   * the user cancelled, or gave up after a failure), so a caller keeps its
+   * selection otherwise.
+   */
+  const confirmBulkAction = async (
+    ids: string[],
+    actionConfig: boolean | RowActionConfig | undefined,
+    action: ConfirmedBulkAction,
+    bulkConfig: BulkActionConfig,
+    rows?: Data[],
+  ): Promise<boolean> => {
+    const fallback = bulkActionConfirm(action, ids.length, t);
+    const run = bulkActionRun(ids, actionConfig, bulkConfig);
+    const declared = declaredBulkConfirm(actionConfig, ids);
+    if (declared) {
+      return askDeclaredBulkConfirm(declared, ids, fallback, run, rows);
+    }
+    return confirm({ ...fallback, onConfirm: run });
+  };
+
+  return { askDeclaredBulkConfirm, confirmBulkAction };
+};
+export const createTableRowBulkActions = (
+  config: TableRowActionsConfig,
+  services: TableRowActionServices,
+  handleApiError: TableRowActionErrorHandler,
+) => {
+  const { t } = services;
+  const { bulkActionRun, performDirectBulkAction } = createTableRowBulkOutcomes(
+    config,
+    services,
+    handleApiError,
+  );
+  const { askDeclaredBulkConfirm, confirmBulkAction } = createBulkConfirmations(
+    config,
+    services,
+    bulkActionRun,
+  );
+  const DELETE_CONFIG: BulkActionConfig = {
+    kind: "delete",
+    method: HttpMethod.delete,
+    queryKey: "id",
+    successKey: "dms.table.delete_rows",
+    errorKey: "dms.table.delete_error",
+  };
+
+  const ARCHIVE_CONFIG: BulkActionConfig = {
+    kind: "archive",
+    method: HttpMethod.put,
+    queryKey: "ids",
+    successKey: "dms.table.archive_rows",
+    errorKey: "dms.table.archive_error",
+  };
+
+  const RESTORE_CONFIG: BulkActionConfig = {
+    kind: "restore",
+    method: HttpMethod.put,
+    queryKey: "ids",
+    successKey: "dms.table.restore_rows",
+    errorKey: "dms.table.restore_error",
+  };
+
+  /**
+   * Deletes rows once confirmed; resolves whether they went (false when the
+   * user cancelled or the request failed), so a caller keeps its selection.
+   */
+  const deleteRows = async (
+    ids: string[],
+    deleteConfig: boolean | RowActionConfig | undefined,
+    options: DeleteRowsOptions = {},
+  ): Promise<boolean> => {
+    if (!normalizeActionConfig(deleteConfig).isEnabled) return false;
+    const action = options.permanently ? "deletePermanently" : "delete";
+    return confirmBulkAction(
+      ids,
+      deleteConfig,
+      action,
+      DELETE_CONFIG,
+      options.rows,
+    );
+  };
+
+  const archiveRows = async (
+    ids: string[],
+    archiveConfig: boolean | RowActionConfig | undefined,
+  ): Promise<boolean> => {
+    if (!normalizeActionConfig(archiveConfig).isEnabled) return false;
+    return confirmBulkAction(ids, archiveConfig, "archive", ARCHIVE_CONFIG);
+  };
+
+  const restoreRows = async (
+    ids: string[],
+    restoreConfig: boolean | RowActionConfig | undefined,
+  ): Promise<boolean> => {
+    if (!normalizeActionConfig(restoreConfig).isEnabled) return false;
+    const declared = declaredBulkConfirm(restoreConfig, ids);
+    if (declared) {
+      return askDeclaredBulkConfirm(
+        declared,
+        ids,
+        {
+          confirmLabel: t("dms.button.restore"),
+          color: "primary",
+          icon: "i-ph-arrow-counter-clockwise",
+        },
+        bulkActionRun(ids, restoreConfig, RESTORE_CONFIG),
+      );
+    }
+    return performDirectBulkAction(ids, restoreConfig, RESTORE_CONFIG);
+  };
+
+  return { deleteRows, archiveRows, restoreRows };
+};

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/tableRowActionBulkRequests.ts

@@ -0,0 +1,157 @@
+import type {
+  TableRowActionsConfig,
+  TableRowActionServices,
+  BulkActionConfig,
+  ConfirmedRun,
+} from "./tableRowActionTypes";
+import { TableViewEvents } from "../../../composables/table-view/types";
+import {
+  bulkActionQuery,
+  bulkActionOutcome,
+  bulkActionShortfall,
+  type BulkActionOutcome,
+} from "./utils/bulkActions";
+import {
+  ConfirmActionError,
+  type ConfirmValues,
+  type ConfirmPartialOutcome,
+} from "../../../composables/confirm/types";
+import { getErrorPayload } from "./tableRowActionValues";
+import type { describeTableWriteError } from "./utils/writeError";
+export type TableRowActionErrorHandler = (
+  error: Parameters<typeof describeTableWriteError>[0],
+  title?: string,
+) => void;
+const createBulkRequest = (config: TableRowActionsConfig) => {
+  const bulkAction = useEventedAction<unknown>({
+    componentId: config.componentId,
+    events: {
+      start: TableViewEvents.ROW_DELETE,
+      success: TableViewEvents.ROW_DELETE_SUCCESS,
+      error: TableViewEvents.ROW_DELETE_ERROR,
+    },
+  });
+
+  /**
+   * Sends a bulk request; resolves how many of the rows it reached. A failed
+   * request rejects, for the caller to show where the user is looking.
+   */
+  const requestBulkAction = async (
+    ids: string[],
+    bulkConfig: BulkActionConfig,
+    values: ConfirmValues = {},
+  ): Promise<BulkActionOutcome> => {
+    const hasValues = Object.keys(values).length > 0;
+    const response = await bulkAction.execute(
+      () => {
+        const request: NonNullable<Parameters<typeof config.api>[1]> = {
+          method: bulkConfig.method,
+          query: bulkActionQuery(bulkConfig.queryKey, ids),
+        };
+        if (hasValues) request.body = values;
+        return config.api(`${config.location}/${bulkConfig.kind}`, request);
+      },
+      {
+        startPayload: { ids },
+        successPayload: () => ({ ids }),
+        errorPayload: (error) => ({ ids, error: getErrorPayload(error) }),
+      },
+    );
+    return bulkActionOutcome(response, ids.length);
+  };
+
+  return requestBulkAction;
+};
+const createBulkReporter = (
+  config: TableRowActionsConfig,
+  services: TableRowActionServices,
+) => {
+  const { toast, t, processI18n } = services;
+  /** Toasts what a bulk action changed, and refreshes the table. */
+  const reportBulkSuccess = (
+    processed: number,
+    actionConfig: boolean | RowActionConfig | undefined,
+    bulkConfig: BulkActionConfig,
+    description?: string,
+  ) => {
+    const { successMessage } = normalizeActionConfig(actionConfig);
+    toast.add({
+      color: description ? Color.warning : Color.success,
+      title: successMessage
+        ? processI18n(successMessage, { count: processed })
+        : t(bulkConfig.successKey, { count: processed }, processed),
+      description,
+    });
+    config.refreshCallback?.();
+  };
+
+  return reportBulkSuccess;
+};
+export const createTableRowBulkOutcomes = (
+  config: TableRowActionsConfig,
+  services: TableRowActionServices,
+  handleApiError: TableRowActionErrorHandler,
+) => {
+  const { toast, t } = services;
+  const requestBulkAction = createBulkRequest(config);
+  const reportBulkSuccess = createBulkReporter(config, services);
+  /**
+   * The `onConfirm` of a bulk action's dialog: the request runs inside it,
+   * so a refusal stays on screen, the dialog open for a retry or a cancel.
+   * Rows a row rule refuses are left out by the server: when none went the
+   * dialog says so (an error), when only some did the rest is done, the
+   * table refreshed, and the dialog sums up what was refused.
+   */
+  const bulkActionRun =
+    (
+      ids: string[],
+      actionConfig: boolean | RowActionConfig | undefined,
+      bulkConfig: BulkActionConfig,
+    ): ConfirmedRun =>
+    async (values: ConfirmValues): Promise<void | ConfirmPartialOutcome> => {
+      const outcome = await requestBulkAction(ids, bulkConfig, values);
+      const shortfall = bulkActionShortfall(bulkConfig.kind, outcome, t);
+      if (outcome.processed === 0 && shortfall) {
+        throw new ConfirmActionError(shortfall);
+      }
+      reportBulkSuccess(outcome.processed, actionConfig, bulkConfig);
+      if (shortfall) return { partial: shortfall };
+    };
+
+  /**
+   * A bulk action without a dialog (a restore): its outcome is toasted, an
+   * error when the request failed or no row went through.
+   */
+  const performDirectBulkAction = async (
+    ids: string[],
+    actionConfig: boolean | RowActionConfig | undefined,
+    bulkConfig: BulkActionConfig,
+  ): Promise<boolean> => {
+    let outcome: BulkActionOutcome;
+    try {
+      outcome = await requestBulkAction(ids, bulkConfig);
+    } catch (error) {
+      handleApiError(error, t(bulkConfig.errorKey));
+      return false;
+    }
+    const shortfall = bulkActionShortfall(bulkConfig.kind, outcome, t);
+    if (outcome.processed === 0) {
+      toast.add({
+        color: Color.error,
+        icon: "i-ph-warning-circle",
+        title: shortfall?.title ?? t(bulkConfig.errorKey),
+        description: shortfall?.description,
+      });
+      return false;
+    }
+    reportBulkSuccess(
+      outcome.processed,
+      actionConfig,
+      bulkConfig,
+      shortfall && `${shortfall.title} ${shortfall.description ?? ""}`.trim(),
+    );
+    return true;
+  };
+
+  return { bulkActionRun, performDirectBulkAction };
+};