@antelopejs/dms 0.0.1

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/action-target.ts

@@ -0,0 +1,48 @@
+export type ActionTarget =
+  | {
+      type: "drawer";
+      component: ComponentInfo;
+      title?: string;
+      description?: string;
+    }
+  | {
+      type: "modal";
+      size?: ModalSize;
+      component: ComponentInfo;
+      title?: string;
+      description?: string;
+    }
+  | { type: "page"; url: string }
+  | { type: "external"; url: string; newTab?: boolean }
+  | {
+      type: "api";
+      url: string;
+      method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+      successMessage: string;
+      confirm?: {
+        title: string;
+        description: string;
+        confirmColor?: "primary" | "error" | "warning";
+      };
+    }
+  | {
+      type: "exportJob";
+      url: string;
+      method?: "GET" | "POST";
+      statusUrl?: string;
+      downloadUrl?: string;
+      labels?: {
+        title?: string;
+        exporting?: string;
+        downloading?: string;
+        successTitle?: string;
+        successMessage?: string;
+        errorTitle?: string;
+        retry?: string;
+      };
+      confirm?: {
+        title: string;
+        description: string;
+        confirmColor?: "primary" | "error" | "warning";
+      };
+    };

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/column.ts

@@ -0,0 +1,39 @@
+export enum AccessMode {
+  ReadOnly = 1,
+  WriteOnly = 2,
+  ReadWrite = 3,
+}
+
+export enum ReadonlyBehaviorMode {
+  disabled = "disabled",
+  hidden = "hidden",
+  default = "default",
+}
+
+export interface ReadonlyBehavior {
+  new?: ReadonlyBehaviorMode;
+  edit?: ReadonlyBehaviorMode;
+  view?: ReadonlyBehaviorMode;
+}
+
+export interface TableViewColumn {
+  id: string;
+  header: string;
+  visible?: boolean;
+  order?: number;
+  accessorKey: string;
+  listable: boolean;
+  type: DataTypeConfig;
+  required?: {
+    new: boolean;
+    edit: boolean;
+  };
+  description?: string;
+  defaultValue?: unknown;
+  accessMode?: AccessMode;
+  readonlyBehavior?: ReadonlyBehaviorMode | ReadonlyBehavior;
+  enableSorting?: boolean;
+  enableColumnFilter?: boolean;
+  /** Wrap grid cell content without a line limit; omitted keeps the theme default. */
+  cellWrap?: boolean;
+}

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/config.ts

@@ -0,0 +1,94 @@
+import type { FormContainer } from "../../../build/composables/table-view/useTableViewConfig";
+import type { TableViewColumn } from "./column";
+import type { TableViewDisplayCapabilities } from "./display";
+import type { CustomButton } from "./custom-button";
+import type { FormProps } from "../../form/types";
+import type { TableProps, TableFilter } from "../../../types/table";
+
+export interface QueryParamFilter {
+  field: string;
+  mode?: string;
+}
+
+export type QueryParamFilters = Record<string, QueryParamFilter>;
+
+export interface RouteParamFilter {
+  field: string;
+  mode?: string;
+}
+
+export type RouteParamFilters = Record<string, RouteParamFilter>;
+
+export interface TableViewTab {
+  id: string;
+  label: string;
+  filters: TableFilter[];
+  icon?: string;
+  textColor?: string;
+  iconColor?: string;
+}
+
+export interface TableViewListResponse<T> {
+  results: T[];
+  total: number;
+  offset: number;
+  limit: number;
+}
+
+export interface KanbanConfig {
+  groupByField: string;
+  cardFields?: string[];
+  cardComponent?: ComponentInfo;
+  draggable?: boolean;
+  columnMaxHeight?: string;
+}
+
+/**
+ * Declares that a table view instance offers a given display (by id), with
+ * optional per-instance options and an optional explicit component reference.
+ * The display *type* (id -> component, capabilities) is registered globally via
+ * `registerTableViewDisplay`; this only opts an instance into it + configures it.
+ */
+export interface TableViewDisplayConfig {
+  /** Matches a registered display id (e.g. "table", "kanban", "cards"). */
+  id: string;
+  /** Per-instance options forwarded to the display via `context.options`. */
+  options?: Record<string, unknown>;
+  /**
+   * Optional component reference (resolved via `resolveDmsComponent`, SSR-safe).
+   * When omitted, the registered display's component is used.
+   */
+  component?: ComponentInfo;
+  /** SSR hint: when true the shared list query is skipped for this display. */
+  selfManagedData?: boolean;
+  /** Chrome shown for this display (SSR source of truth, see TableViewDisplayCapabilities). */
+  capabilities?: TableViewDisplayCapabilities;
+}
+
+export interface TableViewConfig<T extends Data>
+  extends Omit<TableProps<T>, "columns" | "displays"> {
+  location: string;
+  enableTableExport?: boolean;
+  archiveMode?: boolean;
+  defaultFilters?: TableFilter[];
+  columns: TableViewColumn[];
+  labelKey?: string;
+  customButtons?: CustomButton[];
+  formComponents: {
+    new?: ComponentInfo<FormProps>;
+    edit?: ComponentInfo<FormProps>;
+    view?: ComponentInfo<FormProps>;
+  };
+  formContainer?: FormContainer;
+  componentId?: string;
+  pageId?: string;
+  defaultSort?: { field: string; desc?: boolean };
+  queryParamFilters?: QueryParamFilters;
+  routeParamFilters?: RouteParamFilters;
+  routeParams?: Record<string, string>;
+  tabs?: TableViewTab[];
+  /** Displays this table view offers, beyond the implicit built-in `table`. */
+  displays?: TableViewDisplayConfig[];
+  /** Display shown by default when the user has no saved preference. Defaults to "table". */
+  defaultDisplay?: string;
+}

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/custom-button.ts

@@ -0,0 +1,11 @@
+import type { ActionTarget } from "./action-target";
+
+export type CustomButtonVariant = "solid" | "outline" | "ghost" | "link";
+
+export interface CustomButton {
+  label: string;
+  icon?: string;
+  variant?: CustomButtonVariant;
+  color?: ColorValue;
+  target: ActionTarget;
+}

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/display.ts

@@ -0,0 +1,160 @@
+import type { Component } from "vue";
+import type { Table } from "@tanstack/vue-table";
+import type { TableViewColumn } from "./column";
+import type { CustomRowAction } from "../../../types/row-action";
+
+/** The built-in grid display id. */
+export const TABLE_DISPLAY_ID = "table";
+/** The built-in kanban display id. */
+export const KANBAN_DISPLAY_ID = "kanban";
+
+/**
+ * A row "actor" currently editing an item (realtime presence). Keyed by row id
+ * in {@link TableViewPresenceMap}. Part of the public display contract so a
+ * custom display can surface "X is editing this" affordances.
+ */
+export interface TableViewPresenceActor {
+  id: string;
+  displayName?: string;
+  avatarUrl?: string;
+  sessionId: string;
+  since?: number;
+}
+
+export type TableViewPresenceMap = Record<string, TableViewPresenceActor[]>;
+
+/**
+ * Selection API exposed to a display. Keys live in the same id space as
+ * `rowIdKey` (TanStack `getRowId` reads the same key), so a display and the
+ * built-in grid share one selection state.
+ */
+export interface TableViewDisplaySelection {
+  ids: string[];
+  isSelected: (id: string) => boolean;
+  toggle: (id: string, value?: boolean) => void;
+  toggleAll: (value?: boolean) => void;
+  clear: () => void;
+}
+
+/**
+ * Pagination API exposed to a display. For a shared-data display (the common
+ * case) these mutate the table view's global pagination, so changing the page
+ * re-runs the shared list query.
+ */
+export interface TableViewDisplayPagination {
+  pageIndex: number;
+  pageSize: number;
+  total: number;
+  setPage: (index: number) => void;
+  setPageSize: (size: number) => void;
+}
+
+/**
+ * Resolved row-action capabilities + handlers, identical to what the grid uses.
+ * The `canXRow` predicates evaluate per-row rules (e.g. conditional edit/delete)
+ * so a display can gate affordances on individual items.
+ */
+export interface TableViewDisplayActions<T> {
+  canAdd: boolean;
+  canEdit: boolean;
+  canDelete: boolean;
+  canDetails: boolean;
+  canEditRow: (item: T) => boolean;
+  canDeleteRow: (item: T) => boolean;
+  add: () => void;
+  edit: (item: T) => void;
+  delete: (ids: string[]) => void;
+  duplicate: (id: string) => void;
+  details: (item: T) => void;
+  custom: (action: CustomRowAction) => void;
+}
+
+/**
+ * The single, normalized prop every display component receives. A display reads
+ * what it needs and ignores the rest; everything is sourced from the table
+ * view's existing state/handlers so a display inherits search/filters/sorting/
+ * pagination for free (when it consumes the shared list query).
+ */
+export interface TableViewDisplayContext<T = Record<string, unknown>> {
+  /** Current page rows from the shared list query. Empty for self-managed displays. */
+  items: T[];
+  /** Full column metadata (types, labels, accessor keys) — for field rendering. */
+  columns: TableViewColumn[];
+  loading: boolean;
+
+  selection: TableViewDisplaySelection;
+  pagination: TableViewDisplayPagination;
+  actions: TableViewDisplayActions<T>;
+
+  presenceByRow: TableViewPresenceMap;
+  rowIdKey: string;
+  /** Field used as the human label/title of an item, if configured. */
+  labelKey?: string;
+  /** Data API location (`{location}/list`, `/get`, ...). Needed by self-managed displays. */
+  location: string;
+  /** Active filters/search/sort query (no limit/offset) — for self-managed fetching. */
+  query: Record<string, unknown>;
+  /** Stable component/page identifiers, e.g. for per-instance fetch keys. */
+  componentId?: string;
+  pageId?: string;
+  /** Per-instance options declared for this display in the backend config. */
+  options?: Record<string, unknown>;
+  /** Re-fetch the table view (shared list + tab counts + active display). */
+  refresh: () => Promise<void> | void;
+
+  /**
+   * Escape hatch: the TanStack table instance, present when the display is
+   * rendered inside the table body slot. Advanced displays only.
+   */
+  table?: Table<T>;
+}
+
+/**
+ * What chrome the table view shows while a display is active. Column-centric
+ * controls (visibility/pin/size/order) are grid-only; transverse controls
+ * (filters/search/sorting/tabs) default on. Resolved by
+ * `resolveDisplayCapabilities`.
+ */
+export interface TableViewDisplayCapabilities {
+  /** Column visibility/pin/size/order controls. Default false (grid sets true). */
+  columnManagement?: boolean;
+  /** Filters row + filter trigger. Default true. */
+  filters?: boolean;
+  /** Global search box. Default true. */
+  search?: boolean;
+  /** Sort-by-field menu. Default true. */
+  sorting?: boolean;
+  /** Filter tabs. Default true (kanban: false). */
+  tabs?: boolean;
+}
+
+/** Lightweight context passed to {@link TableViewDisplay.isAvailable}. */
+export interface TableViewDisplayAvailabilityContext {
+  columns: TableViewColumn[];
+  options?: Record<string, unknown>;
+}
+
+/**
+ * A registered display ("table", "kanban", or a project/module-contributed one).
+ * Registered from a `.client.ts` plugin via `registerTableViewDisplay`. Holds
+ * presentation only; data behaviour (selfManagedData) and chrome (capabilities)
+ * live on the backend config (SSR source of truth) — see TableViewDisplayConfig.
+ */
+export interface TableViewDisplay {
+  /** Stable id; matches `displays[].id` / `defaultDisplay` and the persisted preference. */
+  id: string;
+  /** i18n key or literal label shown in the view switcher. */
+  label: string;
+  /** Icon shown in the view switcher (e.g. "i-ph-cards"). */
+  icon: string;
+  /**
+   * Body renderer. A `ComponentInfo` (name) is resolved via `resolveDmsComponent`;
+   * a raw `Component` is used as-is. `undefined` means "render the built-in grid"
+   * (used by the `table` display).
+   */
+  component?: Component | ComponentInfo;
+  /** Switcher ordering; lower comes first. Defaults to 100. */
+  order?: number;
+  /** Hide the display for a given table instance (e.g. kanban needs an eligible column). */
+  isAvailable?: (ctx: TableViewDisplayAvailabilityContext) => boolean;
+}

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/events.ts

@@ -0,0 +1,23 @@
+export const TableViewEvents = {
+  ROW_CLICK: "DmsComponent.TableView.RowClick",
+  ROW_CLICK_SUCCESS: "DmsComponent.TableView.RowClickSuccess",
+  ROW_CLICK_ERROR: "DmsComponent.TableView.RowClickError",
+  ROW_SELECT: "DmsComponent.TableView.RowSelect",
+  ROW_DELETE: "DmsComponent.TableView.RowDelete",
+  ROW_DELETE_SUCCESS: "DmsComponent.TableView.RowDeleteSuccess",
+  ROW_DELETE_ERROR: "DmsComponent.TableView.RowDeleteError",
+  ROW_ADD: "DmsComponent.TableView.RowAdd",
+  ROW_ADD_SUCCESS: "DmsComponent.TableView.RowAddSuccess",
+  ROW_ADD_ERROR: "DmsComponent.TableView.RowAddError",
+  ROW_EDIT: "DmsComponent.TableView.RowEdit",
+  ROW_EDIT_SUCCESS: "DmsComponent.TableView.RowEditSuccess",
+  ROW_EDIT_ERROR: "DmsComponent.TableView.RowEditError",
+  ROW_DUPLICATE: "DmsComponent.TableView.RowDuplicate",
+  ROW_DUPLICATE_SUCCESS: "DmsComponent.TableView.RowDuplicateSuccess",
+  ROW_DUPLICATE_ERROR: "DmsComponent.TableView.RowDuplicateError",
+  FILTER_CHANGE: "DmsComponent.TableView.FilterChange",
+  SORT_CHANGE: "DmsComponent.TableView.SortChange",
+  EXPORT: "DmsComponent.TableView.Export",
+  EXPORT_SUCCESS: "DmsComponent.TableView.ExportSuccess",
+  EXPORT_ERROR: "DmsComponent.TableView.ExportError",
+} as const;

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/functions.ts

@@ -0,0 +1,3 @@
+export const TableViewFunctions = {
+  CUSTOM_PAGE_FORM_SUCCESS: "DmsComponent.TableView.CustomPageFormSuccess",
+} as const;

package/frontend-vue/layers/dms-ui/app/composables/table-view/types/index.ts

@@ -0,0 +1,5 @@
+export * from "./column";
+export * from "./config";
+export * from "./custom-button";
+export * from "./display";
+export * from "./events";

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

@@ -0,0 +1,66 @@
+import type {
+  TableViewDisplay,
+  TableViewDisplayCapabilities,
+} from "./types/display";
+
+const TABLE_VIEW_DISPLAYS_STATE_KEY = "dms:table-view-displays";
+const DEFAULT_ORDER = 100;
+
+function useDisplayState() {
+  return useDmsState<TableViewDisplay[]>(TABLE_VIEW_DISPLAYS_STATE_KEY, () => []);
+}
+
+function displayOrder(display: TableViewDisplay): number {
+  return display.order ?? DEFAULT_ORDER;
+}
+
+/**
+ * Register (or replace, by id) a table view display. Keyed DMS app state lets any
+ * module register without a build-time dependency on this layer. Call from a
+ * `.client.ts` plugin: displays carry callables (component, isAvailable) that are
+ * stripped from the SSR payload, so the registry is client-only. Data behaviour
+ * and chrome (selfManagedData/capabilities) are config-driven for SSR safety; the
+ * registry powers the client-side switcher and component resolution.
+ */
+export function registerTableViewDisplay(display: TableViewDisplay): void {
+  const displays = useDisplayState();
+  const existingIndex = displays.value.findIndex(
+    (entry) => entry.id === display.id,
+  );
+
+  if (existingIndex === -1) {
+    displays.value = [...displays.value, display];
+    return;
+  }
+
+  const next = [...displays.value];
+  next[existingIndex] = display;
+  displays.value = next;
+}
+
+export function useTableViewDisplays() {
+  const displays = useDisplayState();
+  const all = computed<TableViewDisplay[]>(() =>
+    [...displays.value].sort((a, b) => displayOrder(a) - displayOrder(b)),
+  );
+  const getById = (id: string): TableViewDisplay | undefined =>
+    all.value.find((entry) => entry.id === id);
+
+  return { displays: all, getById };
+}
+
+/**
+ * Apply capability defaults: column management is grid-only (off by default); the
+ * transverse controls (filters/search/sorting/tabs) default on.
+ */
+export function resolveDisplayCapabilities(
+  capabilities?: TableViewDisplayCapabilities,
+): Required<TableViewDisplayCapabilities> {
+  return {
+    columnManagement: capabilities?.columnManagement ?? false,
+    filters: capabilities?.filters ?? true,
+    search: capabilities?.search ?? true,
+    sorting: capabilities?.sorting ?? true,
+    tabs: capabilities?.tabs ?? true,
+  };
+}

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

@@ -0,0 +1,49 @@
+interface UseTableViewExportOptions {
+  componentId?: string;
+}
+
+export const useTableViewExport = (options: UseTableViewExportOptions = {}) => {
+  const { runJob } = useExportJob();
+
+  const exportAction = useEventedAction<unknown>({
+    componentId: options.componentId,
+    events: {
+      start: TableViewEvents.EXPORT,
+      success: TableViewEvents.EXPORT_SUCCESS,
+      error: TableViewEvents.EXPORT_ERROR,
+    },
+  });
+
+  async function exportTable(
+    location: string,
+    queryRequest: TableQueryParams,
+    ids?: string[],
+  ) {
+    const query =
+      ids && ids.length > 0 ? { ...queryRequest, ids } : queryRequest;
+    await exportAction.execute(
+      () =>
+        runJob({
+          startUrl: `${location}/export/start`,
+          startMethod: "GET",
+          startQuery: query as Record<string, unknown>,
+          statusUrl: (ticket) => `${location}/export/status/${ticket.jobId}`,
+          downloadUrl: (ticket) =>
+            `${location}/export/download/${ticket.jobId}`,
+        }),
+      {
+        startPayload: { query: queryRequest, ids },
+        successPayload: () => ({ query: queryRequest, ids }),
+        errorPayload: (error) => ({
+          query: queryRequest,
+          ids,
+          error:
+            (error as { data?: string; message?: string })?.data ||
+            (error as Error)?.message,
+        }),
+      },
+    );
+  }
+
+  return { exportTable };
+};

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/index.ts

@@ -0,0 +1,50 @@
+import {
+  TREE_ARROW_DOWN_METADATA,
+  createTreeArrowDownShortcut,
+} from "./treeArrowDown";
+import {
+  TREE_ARROW_UP_METADATA,
+  createTreeArrowUpShortcut,
+} from "./treeArrowUp";
+import { TREE_ENTER_METADATA, createTreeEnterShortcut } from "./treeEnter";
+import { TREE_SPACE_METADATA, createTreeSpaceShortcut } from "./treeSpace";
+import { TREE_HOME_METADATA, createTreeHomeShortcut } from "./treeHome";
+import { TREE_END_METADATA, createTreeEndShortcut } from "./treeEnd";
+import { TREE_SHIFT_A_METADATA, createTreeShiftAShortcut } from "./treeShiftA";
+import { TREE_ESCAPE_METADATA, createTreeEscapeShortcut } from "./treeEscape";
+
+export const TREE_SHORTCUTS_METADATA = [
+  TREE_ARROW_DOWN_METADATA,
+  TREE_ARROW_UP_METADATA,
+  TREE_ENTER_METADATA,
+  TREE_SPACE_METADATA,
+  TREE_HOME_METADATA,
+  TREE_END_METADATA,
+  TREE_SHIFT_A_METADATA,
+  TREE_ESCAPE_METADATA,
+];
+
+interface BuildTreeShortcutsParams {
+  navigateTree: (direction: TreeNavigationDirection) => void;
+  props: TreeProps;
+  items: ComputedRef<TreeNode[]>;
+  selected: Ref<TreeNode | TreeNode[] | undefined>;
+}
+
+export function buildTreeShortcuts({
+  navigateTree,
+  props,
+  items,
+  selected,
+}: BuildTreeShortcutsParams): Record<string, () => void> {
+  return {
+    arrowdown: createTreeArrowDownShortcut(navigateTree),
+    arrowup: createTreeArrowUpShortcut(navigateTree),
+    enter: createTreeEnterShortcut(navigateTree),
+    space: createTreeSpaceShortcut(navigateTree),
+    home: createTreeHomeShortcut(navigateTree),
+    end: createTreeEndShortcut(navigateTree),
+    shift_a: createTreeShiftAShortcut(props, items, selected),
+    escape: createTreeEscapeShortcut(props, selected),
+  };
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeArrowDown.ts

@@ -0,0 +1,11 @@
+export const TREE_ARROW_DOWN_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.arrowdown"],
+  descriptionKey: "$dms.shortcuts.tree.arrowdown.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeArrowDownShortcut(
+  navigateTree: (direction: TreeNavigationDirection) => void,
+) {
+  return () => navigateTree(TreeNavigationDirection.DOWN);
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeArrowUp.ts

@@ -0,0 +1,11 @@
+export const TREE_ARROW_UP_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.arrowup"],
+  descriptionKey: "$dms.shortcuts.tree.arrowup.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeArrowUpShortcut(
+  navigateTree: (direction: TreeNavigationDirection) => void,
+) {
+  return () => navigateTree(TreeNavigationDirection.UP);
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeEnd.ts

@@ -0,0 +1,11 @@
+export const TREE_END_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.end"],
+  descriptionKey: "$dms.shortcuts.tree.end.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeEndShortcut(
+  navigateTree: (direction: TreeNavigationDirection) => void,
+) {
+  return () => navigateTree(TreeNavigationDirection.END);
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeEnter.ts

@@ -0,0 +1,11 @@
+export const TREE_ENTER_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.enter"],
+  descriptionKey: "$dms.shortcuts.tree.enter.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeEnterShortcut(
+  navigateTree: (direction: TreeNavigationDirection) => void,
+) {
+  return () => navigateTree(TreeNavigationDirection.SELECT);
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeEscape.ts

@@ -0,0 +1,14 @@
+export const TREE_ESCAPE_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.escape"],
+  descriptionKey: "$dms.shortcuts.tree.escape.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeEscapeShortcut(
+  props: TreeProps,
+  selected: Ref<TreeNode | TreeNode[] | undefined>,
+) {
+  return () => {
+    selected.value = props.multiple ? [] : undefined;
+  };
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeHome.ts

@@ -0,0 +1,11 @@
+export const TREE_HOME_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.home"],
+  descriptionKey: "$dms.shortcuts.tree.home.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeHomeShortcut(
+  navigateTree: (direction: TreeNavigationDirection) => void,
+) {
+  return () => navigateTree(TreeNavigationDirection.HOME);
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeShiftA.ts

@@ -0,0 +1,32 @@
+export const TREE_SHIFT_A_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.shift", "a"],
+  descriptionKey: "$dms.shortcuts.tree.shift_a.description",
+  component: "$dms.components.tree",
+  condition: {
+    descriptionKey: "$dms.shortcuts.tree.shift_a.condition",
+    check: "multiple",
+  },
+};
+
+const selectAllNodes = (nodes: TreeNode[]): TreeNode[] => {
+  const result: TreeNode[] = [];
+  nodes.forEach((node) => {
+    result.push(node);
+    if (node.children) {
+      result.push(...selectAllNodes(node.children));
+    }
+  });
+  return result;
+};
+
+export function createTreeShiftAShortcut(
+  props: TreeProps,
+  items: ComputedRef<TreeNode[]>,
+  selected: Ref<TreeNode | TreeNode[] | undefined>,
+) {
+  return () => {
+    if (props.multiple && items.value.length > 0) {
+      selected.value = selectAllNodes(items.value) as TreeNode[];
+    }
+  };
+}

package/frontend-vue/layers/dms-ui/app/composables/tree/shortcuts/treeSpace.ts

@@ -0,0 +1,11 @@
+export const TREE_SPACE_METADATA: ShortcutMetadata = {
+  key: ["$keyboard.space"],
+  descriptionKey: "$dms.shortcuts.tree.space.description",
+  component: "$dms.components.tree",
+};
+
+export function createTreeSpaceShortcut(
+  navigateTree: (direction: TreeNavigationDirection) => void,
+) {
+  return () => navigateTree(TreeNavigationDirection.SELECT);
+}