@antelopejs/dms 0.0.1

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

@@ -0,0 +1,356 @@
+import { h } from "vue";
+import DmsExportToastContent from "../components/table-view/ExportToastContent.vue";
+
+const POLLING_INTERVAL_MS = 400;
+const EXPORT_TOAST_DURATION = 5000;
+const ONE_HOUR_MS = 60 * 60 * 1000;
+const TOAST_DURATION_UNTIL_REPLACED = ONE_HOUR_MS;
+const FILENAME_HEADER_PATTERN = /filename="([^"]+)"/i;
+
+function parseFilenameFromContentDisposition(
+  header: string | null,
+): string | null {
+  if (!header) return null;
+  const match = header.match(FILENAME_HEADER_PATTERN);
+  return match?.[1] ?? null;
+}
+
+type ProgressValue = number | null;
+
+export interface ExportJobTicket {
+  jobId: string;
+  extension?: string;
+  filename?: string;
+}
+
+export interface ExportJobStatusResponse {
+  status: string;
+  progress: number;
+  error?: string;
+  filename?: string;
+  extension?: string;
+}
+
+export interface UseExportJobLabels {
+  title: string;
+  exporting: string;
+  downloading: string;
+  successTitle: string;
+  successMessage: string;
+  errorTitle: string;
+  fallbackErrorTitle: string;
+  retry: string;
+}
+
+export interface RunExportJobOptions {
+  startUrl: string;
+  startMethod?: "GET" | "POST";
+  startQuery?: Record<string, unknown>;
+  startBody?: Record<string, unknown>;
+  /** Function from jobId → URL. Defaults to `${startBase}/status/${jobId}`. */
+  statusUrl?: (ticket: ExportJobTicket) => string;
+  /** Function from jobId → URL. Defaults to `${startBase}/download/${jobId}`. */
+  downloadUrl?: (ticket: ExportJobTicket) => string;
+  /**
+   * Fallback when the response headers carry no filename (headers always
+   * win). Defaults to `${ticket.filename}.${extension}`, or
+   * `export-${jobId}.${extension}` when the ticket has no filename.
+   */
+  fallbackFilename?: (ticket: ExportJobTicket) => string;
+  /**
+   * i18n labels override (defaults to `dms.table.export.*`, except
+   * `fallbackErrorTitle` which defaults to `dms.form.error_title`).
+   */
+  labels?: Partial<UseExportJobLabels>;
+  /** Show a retry button in the failure toast (defaults to true). */
+  retryable?: boolean;
+}
+
+const EXPORT_STATUS_COMPLETED = "completed";
+const EXPORT_STATUS_FAILED = "failed";
+
+export const useExportJob = () => {
+  const toast = useToast();
+  const { t } = useI18n();
+  const { processApiMessage } = useTranslation();
+  const { $authFetch } = useAuthFetch();
+
+  function resolveLabels(
+    overrides?: Partial<UseExportJobLabels>,
+  ): UseExportJobLabels {
+    const merged = overrides ?? {};
+    return {
+      title: merged.title ?? t("dms.table.export.title"),
+      exporting: merged.exporting ?? t("dms.table.export.exporting"),
+      downloading: merged.downloading ?? t("dms.table.export.downloading"),
+      successTitle: merged.successTitle ?? t("dms.table.export.success_title"),
+      successMessage:
+        merged.successMessage ?? t("dms.table.export.success_message"),
+      errorTitle: merged.errorTitle ?? t("dms.table.export.error_title"),
+      fallbackErrorTitle:
+        merged.fallbackErrorTitle ?? t("dms.form.error_title"),
+      retry: merged.retry ?? t("dms.table.export.retry"),
+    };
+  }
+
+  function renderProgressDescription(label: string, progress: ProgressValue) {
+    return () => h(DmsExportToastContent, { label, progress });
+  }
+
+  function createExportToast(labels: UseExportJobLabels) {
+    return toast.add({
+      color: Color.info,
+      icon: "i-ph-export",
+      title: labels.title,
+      description: renderProgressDescription(labels.exporting, 0),
+      duration: TOAST_DURATION_UNTIL_REPLACED,
+      progress: false,
+    });
+  }
+
+  function updateProgressToast(
+    toastId: string | number,
+    label: string,
+    progress: ProgressValue,
+  ) {
+    toast.update(toastId, {
+      description: renderProgressDescription(label, progress),
+      duration: TOAST_DURATION_UNTIL_REPLACED,
+      progress: false,
+    });
+  }
+
+  function replaceProgressToast(
+    toastId: string | number,
+    payload: Parameters<typeof toast.add>[0],
+  ): string | number {
+    toast.remove(toastId);
+    const next = toast.add(payload);
+    return next.id;
+  }
+
+  function showSuccess(toastId: string | number, labels: UseExportJobLabels) {
+    replaceProgressToast(toastId, {
+      color: Color.success,
+      icon: "i-ph-check-circle",
+      title: labels.successTitle,
+      description: labels.successMessage,
+      duration: EXPORT_TOAST_DURATION,
+      progress: true,
+    });
+  }
+
+  function buildRetryActions(
+    opts: RunExportJobOptions,
+    labels: UseExportJobLabels,
+    getCurrentToastId: () => string | number,
+  ): { label: string; onClick: () => void }[] | undefined {
+    if (opts.retryable === false) return undefined;
+    return [
+      {
+        label: labels.retry,
+        onClick: () => {
+          toast.remove(getCurrentToastId());
+          void runJob(opts);
+        },
+      },
+    ];
+  }
+
+  function showFailure(
+    toastId: string | number,
+    opts: RunExportJobOptions,
+    labels: UseExportJobLabels,
+    error?: string,
+  ): string | number {
+    let newId: string | number = toastId;
+    newId = replaceProgressToast(toastId, {
+      color: Color.error,
+      icon: "i-ph-warning",
+      title: labels.errorTitle,
+      description: error ? processApiMessage(error) : labels.fallbackErrorTitle,
+      duration: EXPORT_TOAST_DURATION,
+      progress: true,
+      actions: buildRetryActions(opts, labels, () => newId),
+    });
+    return newId;
+  }
+
+  function showError(
+    toastId: string | number,
+    opts: RunExportJobOptions,
+    labels: UseExportJobLabels,
+    error: Error,
+  ): string | number {
+    let newId: string | number = toastId;
+    newId = replaceProgressToast(toastId, {
+      color: Color.error,
+      icon: "i-ph-warning",
+      title: labels.fallbackErrorTitle,
+      description: processApiMessage(error.message),
+      duration: EXPORT_TOAST_DURATION,
+      progress: true,
+      actions: buildRetryActions(opts, labels, () => newId),
+    });
+    return newId;
+  }
+
+  async function startJob(opts: RunExportJobOptions): Promise<ExportJobTicket> {
+    const method = opts.startMethod ?? "POST";
+    const init: Record<string, unknown> = { method };
+    if (opts.startQuery) init.query = opts.startQuery;
+    if (opts.startBody && method !== "GET") init.body = opts.startBody;
+    const ticket = await $authFetch<ExportJobTicket>(opts.startUrl, init);
+    return ticket;
+  }
+
+  function resolveStatusUrl(
+    opts: RunExportJobOptions,
+    ticket: ExportJobTicket,
+  ): string {
+    if (opts.statusUrl) return opts.statusUrl(ticket);
+    const base = opts.startUrl.replace(/\/start$/, "");
+    return `${base}/status/${ticket.jobId}`;
+  }
+
+  function resolveDownloadUrl(
+    opts: RunExportJobOptions,
+    ticket: ExportJobTicket,
+  ): string {
+    if (opts.downloadUrl) return opts.downloadUrl(ticket);
+    const base = opts.startUrl.replace(/\/start$/, "");
+    return `${base}/download/${ticket.jobId}`;
+  }
+
+  async function readStreamWithProgress(
+    stream: ReadableStream<Uint8Array>,
+    totalBytes: number,
+    onProgress: (progress: ProgressValue) => void,
+  ): Promise<Blob> {
+    const reader = stream.getReader();
+    const chunks: Uint8Array[] = [];
+    let receivedBytes = 0;
+
+    onProgress(totalBytes > 0 ? 0 : null);
+
+    let chunk = await reader.read();
+    while (!chunk.done) {
+      chunks.push(chunk.value);
+      receivedBytes += chunk.value.length;
+      if (totalBytes > 0) {
+        onProgress(Math.floor((receivedBytes / totalBytes) * 100));
+      }
+      chunk = await reader.read();
+    }
+
+    if (totalBytes > 0 && receivedBytes !== totalBytes) {
+      throw new Error(
+        `Download incomplete: received ${receivedBytes} of ${totalBytes} bytes`,
+      );
+    }
+
+    return new Blob(chunks as BlobPart[]);
+  }
+
+  async function pollStatus(
+    statusUrl: string,
+    toastId: string | number,
+    labels: UseExportJobLabels,
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const interval = setInterval(async () => {
+        try {
+          const status = await $authFetch<ExportJobStatusResponse>(statusUrl);
+          if (status.status === EXPORT_STATUS_COMPLETED) {
+            clearInterval(interval);
+            updateProgressToast(toastId, labels.exporting, 100);
+            resolve();
+            return;
+          }
+          if (status.status === EXPORT_STATUS_FAILED) {
+            clearInterval(interval);
+            reject(new Error(status.error));
+            return;
+          }
+          updateProgressToast(toastId, labels.exporting, status.progress);
+        } catch (error) {
+          clearInterval(interval);
+          reject(error);
+        }
+      }, POLLING_INTERVAL_MS);
+    });
+  }
+
+  async function downloadResult(
+    downloadUrl: string,
+    ticket: ExportJobTicket,
+    fallbackFilename: (t: ExportJobTicket) => string,
+    toastId: string | number,
+    labels: UseExportJobLabels,
+  ): Promise<void> {
+    updateProgressToast(toastId, labels.downloading, 0);
+
+    const response = await $authFetch.raw(downloadUrl, {
+      responseType: "stream",
+    });
+
+    const stream = response._data as ReadableStream<Uint8Array> | null;
+    if (!stream) throw new Error("Empty download stream");
+    const totalBytes = Number(response.headers.get("content-length")) || 0;
+    const serverFilename = parseFilenameFromContentDisposition(
+      response.headers.get("content-disposition"),
+    );
+
+    const blob = await readStreamWithProgress(stream, totalBytes, (progress) =>
+      updateProgressToast(toastId, labels.downloading, progress),
+    );
+
+    const objectUrl = URL.createObjectURL(blob);
+    try {
+      const filename = serverFilename || fallbackFilename(ticket);
+      downloadFile(objectUrl, filename);
+    } finally {
+      URL.revokeObjectURL(objectUrl);
+    }
+  }
+
+  function getErrorMessage(error: unknown): string | undefined {
+    const err = error as { data?: unknown; message?: unknown };
+    const data = err?.data as string | undefined;
+    const message = err?.message as string | undefined;
+    return data || message;
+  }
+
+  async function runJob(opts: RunExportJobOptions): Promise<void> {
+    const labels = resolveLabels(opts.labels);
+    const fallbackFilename =
+      opts.fallbackFilename ??
+      ((ticket: ExportJobTicket) =>
+        ticket.filename
+          ? `${ticket.filename}.${ticket.extension ?? "bin"}`
+          : `export-${ticket.jobId}.${ticket.extension ?? "bin"}`);
+
+    const exportToast = createExportToast(labels);
+
+    try {
+      const ticket = await startJob(opts);
+      const statusUrl = resolveStatusUrl(opts, ticket);
+      const downloadUrl = resolveDownloadUrl(opts, ticket);
+      await pollStatus(statusUrl, exportToast.id, labels);
+      await downloadResult(
+        downloadUrl,
+        ticket,
+        fallbackFilename,
+        exportToast.id,
+        labels,
+      );
+      showSuccess(exportToast.id, labels);
+    } catch (error) {
+      const message = getErrorMessage(error);
+      if (message) showFailure(exportToast.id, opts, labels, message);
+      else showError(exportToast.id, opts, labels, error as Error);
+    }
+  }
+
+  return { runJob };
+};

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

@@ -0,0 +1,105 @@
+import { FORM_CONTENT_LANGUAGE_KEY } from "./form/types/content-language";
+
+interface FileMetadataUrlResponse {
+  url: string;
+  expiresAt?: number;
+}
+
+type CachedFileReadUrl = FileMetadataUrlResponse;
+
+const URL_REFRESH_LEAD_MS = 5000;
+const RETRY_DELAY_MS = 5000;
+
+/**
+ * Resolves stored file resource keys to read URLs through
+ * `/api/files/metadata`. Expiring URLs refresh while visible, and failed
+ * lookups remain retryable instead of permanently hiding the file.
+ */
+export function useFileReadUrls(storage?: string) {
+  const { $authFetch } = useAuthFetch();
+  const contentLanguage = inject(FORM_CONTENT_LANGUAGE_KEY, undefined);
+  const urls = ref<Map<string, CachedFileReadUrl>>(new Map());
+  const pendingKeys = new Set<string>();
+  const refreshTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  let isDisposed = false;
+
+  function isFresh(metadata: CachedFileReadUrl): boolean {
+    return (
+      metadata.expiresAt === undefined ||
+      metadata.expiresAt - URL_REFRESH_LEAD_MS > Date.now()
+    );
+  }
+
+  function scheduleRefresh(key: string, expiresAt?: number): void {
+    if (isDisposed || import.meta.env.SSR) return;
+    const currentTimer = refreshTimers.get(key);
+    if (currentTimer) clearTimeout(currentTimer);
+    if (expiresAt === undefined) return;
+    const remaining = Math.max(expiresAt - Date.now(), 0);
+    const refreshLead = Math.min(URL_REFRESH_LEAD_MS, remaining / 2);
+    const delay = Math.max(remaining - refreshLead, 0);
+    refreshTimers.set(
+      key,
+      setTimeout(() => resolve(key, true), delay),
+    );
+  }
+
+  async function resolve(key: string, force = false): Promise<void> {
+    if (isDisposed) return;
+    const cached = urls.value.get(key);
+    if (!force && cached && isFresh(cached)) return;
+    if (pendingKeys.has(key)) return;
+
+    pendingKeys.add(key);
+    try {
+      const metadata = await $authFetch<FileMetadataUrlResponse>(
+        "/api/files/metadata",
+        {
+          query: { resourceKey: key, storage },
+          headers: contentLanguage
+            ? { [CONTENT_LANGUAGE_HEADER]: contentLanguage }
+            : undefined,
+        },
+      );
+      if (isDisposed) return;
+      urls.value.set(key, metadata);
+      scheduleRefresh(key, metadata.expiresAt);
+    } catch {
+      if (isDisposed) return;
+      if (cached?.expiresAt !== undefined && cached.expiresAt <= Date.now()) {
+        urls.value.delete(key);
+      } else if (cached?.expiresAt !== undefined) {
+        scheduleRefresh(key, cached.expiresAt);
+      }
+      if (
+        !import.meta.env.SSR &&
+        (!cached ||
+          (cached.expiresAt !== undefined && cached.expiresAt <= Date.now()))
+      ) {
+        refreshTimers.set(
+          key,
+          setTimeout(() => resolve(key, true), RETRY_DELAY_MS),
+        );
+      }
+    }
+    pendingKeys.delete(key);
+  }
+
+  function getUrl(key: string): string | undefined {
+    const metadata = urls.value.get(key);
+    if (
+      !metadata ||
+      (metadata.expiresAt !== undefined && metadata.expiresAt <= Date.now())
+    ) {
+      return undefined;
+    }
+    return metadata.url;
+  }
+
+  onScopeDispose(() => {
+    isDisposed = true;
+    refreshTimers.forEach(clearTimeout);
+  });
+
+  return { getUrl, resolve };
+}

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

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import type { Ref, ComputedRef } from "vue";
+
+export interface PasswordRequirement {
+  met: boolean;
+  text: string;
+}
+
+const MIN_PASSWORD_LENGTH = 8;
+const ALLOWED_SPECIAL_CHARS = "@$!%*?&";
+const ALLOWED_CHARS_REGEX = /^[A-Za-z\d@$!%*?&]+$/;
+
+const PASSWORD_REQUIREMENTS = [
+  { regex: /.{8,}/, messageKey: "form.password_strength.min" },
+  { regex: /[A-Z]/, messageKey: "form.password_strength.upercase" },
+  { regex: /\d/, messageKey: "form.password_strength.number" },
+  {
+    regex: /[@$!%*?&]/,
+    messageKey: "form.password_strength.special",
+    suffix: ` (${ALLOWED_SPECIAL_CHARS})`,
+  },
+  {
+    regex: ALLOWED_CHARS_REGEX,
+    messageKey: "form.password_strength.allowed_only",
+  },
+];
+
+const SCORE_THRESHOLDS = {
+  error: 1,
+  warning: 4,
+} as const;
+
+type StrengthColor =
+  | "error"
+  | "primary"
+  | "secondary"
+  | "success"
+  | "info"
+  | "warning"
+  | "neutral";
+
+export const passwordSchema = z
+  .string()
+  .min(MIN_PASSWORD_LENGTH, { message: "" })
+  .regex(/[A-Z]/, { message: "" })
+  .regex(/\d/, { message: "" })
+  .regex(/[@$!%*?&]/, { message: "" })
+  .regex(ALLOWED_CHARS_REGEX, { message: "" });
+
+export function usePasswordStrength(password: Ref<string>) {
+  const { t } = useI18n();
+
+  const strength: ComputedRef<PasswordRequirement[]> = computed(() =>
+    PASSWORD_REQUIREMENTS.map((req) => ({
+      met: req.regex.test(password.value || ""),
+      text: t(req.messageKey) + (req.suffix ?? ""),
+    })),
+  );
+
+  const score: ComputedRef<number> = computed(
+    () => strength.value.filter((req) => req.met).length,
+  );
+
+  const color: ComputedRef<StrengthColor> = computed(() => {
+    if (score.value <= SCORE_THRESHOLDS.error) return "error";
+    if (score.value <= SCORE_THRESHOLDS.warning) return "warning";
+    return "success";
+  });
+
+  return { strength, score, color, passwordSchema };
+}

package/frontend-vue/layers/dms-ui/app/config/shortcuts-registry.ts

@@ -0,0 +1,19 @@
+import { TAB_SHORTCUTS_METADATA } from "../composables/tab/shortcuts";
+import { TABLE_VIEW_SHORTCUTS_METADATA } from "../composables/table-view/shortcuts";
+import { TREE_SHORTCUTS_METADATA } from "../composables/tree/shortcuts";
+import type { ComponentShortcuts } from "../types/shortcuts";
+
+export default [
+  {
+    component: "Tab",
+    shortcuts: TAB_SHORTCUTS_METADATA,
+  },
+  {
+    component: "TableView",
+    shortcuts: TABLE_VIEW_SHORTCUTS_METADATA,
+  },
+  {
+    component: "Tree",
+    shortcuts: TREE_SHORTCUTS_METADATA,
+  },
+] satisfies ComponentShortcuts[];

package/frontend-vue/layers/dms-ui/app/plugins/register.ts

@@ -0,0 +1,9 @@
+import { registerDefaultDataTypes } from "../build/composables/data-types/registerDefaults";
+import { registerDefaultFunctions } from "../build/composables/table-view/registerDefaultFunctions";
+import { registerFormFunctions } from "../build/composables/form/registerFormFunctions";
+
+export default defineDmsPlugin(() => {
+  registerDefaultDataTypes();
+  registerDefaultFunctions();
+  registerFormFunctions();
+});

package/frontend-vue/layers/dms-ui/app/plugins/shortcuts.ts

@@ -0,0 +1,10 @@
+import aggregatedShortcuts from "../config/shortcuts-registry";
+export default defineDmsPlugin(() => {
+  const { registerShortcut } = useShortcutRegistry();
+
+  for (const componentShortcuts of aggregatedShortcuts) {
+    for (const shortcut of componentShortcuts.shortcuts) {
+      registerShortcut(componentShortcuts.component, shortcut);
+    }
+  }
+});

package/frontend-vue/layers/dms-ui/app/plugins/table-view-displays.client.ts

@@ -0,0 +1,31 @@
+import { defineAsyncComponent } from "vue";
+import { isEligibleKanbanColumn } from "../composables/table-view/kanban";
+import {
+  KANBAN_DISPLAY_ID,
+  TABLE_DISPLAY_ID,
+} from "../composables/table-view/types";
+
+const KanbanDisplay = defineAsyncComponent(
+  () => import("../components/table-view/KanbanDisplay.vue"),
+);
+
+// Registers the presentation of the built-in displays (client-only: displays
+// carry callables stripped from the SSR payload). Data behaviour and chrome
+// (selfManagedData/capabilities) are config-driven for SSR safety.
+export default defineDmsPlugin(() => {
+  registerTableViewDisplay({
+    id: TABLE_DISPLAY_ID,
+    label: "dms.table.view_mode_table",
+    icon: "i-ph-rows",
+    order: 10,
+  });
+
+  registerTableViewDisplay({
+    id: KANBAN_DISPLAY_ID,
+    label: "dms.table.view_mode_kanban",
+    icon: "i-ph-kanban",
+    order: 20,
+    component: KanbanDisplay,
+    isAvailable: (ctx) => ctx.columns.some(isEligibleKanbanColumn),
+  });
+});

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

@@ -0,0 +1,9 @@
+export type ModalSize =
+  | "sm"
+  | "md"
+  | "lg"
+  | "xl"
+  | "2xl"
+  | "3xl"
+  | "4xl"
+  | "5xl";

package/frontend-vue/layers/dms-ui/app/types/quick-actions.ts

@@ -0,0 +1,11 @@
+/**
+ * How an `openForm` quick action reaches its table view: it routes to the
+ * action's page with these query parameters, and the table view opens its
+ * creation form when it mounts. Carried by the URL rather than a window event
+ * so the action works from any page — the listener would otherwise have to
+ * exist before the navigation that creates it.
+ */
+export const QUICK_ACTION_QUERY_KEY = "quickAction";
+export const QUICK_ACTION_ADD = "add";
+/** Which table view answers, when the page mounts more than one. */
+export const QUICK_ACTION_COMPONENT_KEY = "quickActionComponent";

package/frontend-vue/layers/dms-ui/app/types/row-action.ts

@@ -0,0 +1,12 @@
+import type { ActionTarget } from "../composables/table-view/types/action-target";
+import type { RowActionRule } from "#dms-core/app/types/row-action";
+
+export interface CustomRowAction {
+  label: string;
+  icon?: string;
+  target: ActionTarget;
+  rule?: RowActionRule;
+  visible?: boolean;
+  /** Preferred row-click target when its rule accepts the row. */
+  isDefault?: boolean;
+}

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

@@ -0,0 +1,16 @@
+export interface ShortcutCondition {
+  descriptionKey: string;
+  check?: string;
+}
+
+export interface ShortcutMetadata {
+  key: string[];
+  descriptionKey: string;
+  component: string;
+  condition?: ShortcutCondition;
+}
+
+export interface ComponentShortcuts {
+  component: string;
+  shortcuts: ShortcutMetadata[];
+}

package/frontend-vue/layers/dms-ui/app/types/table/base.ts

@@ -0,0 +1,10 @@
+export type {
+  Data,
+  TableColumn,
+  TableRowActionOptions,
+  NavItem,
+  TableProps,
+  TableEmits,
+  TableFilter,
+  TableSharedData,
+} from "../../build/components/table/Table.vue";

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

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./query";

package/frontend-vue/layers/dms-ui/app/types/table/query.ts

@@ -0,0 +1,14 @@
+export enum SortDirection {
+  asc = "asc",
+  desc = "desc",
+}
+
+export interface TableQueryParams {
+  search?: string;
+  offset: number;
+  limit: number;
+  sortKey?: string;
+  sortDirection?: SortDirection;
+  showArchived?: boolean;
+  [key: `filter_${string}`]: string | number | undefined;
+}