@antelopejs/dms 0.0.1

package/frontend-vue/layers/dms-core/app/utils/formatter.ts

@@ -0,0 +1,280 @@
+import { isNumber } from "./type-check";
+
+const DEFAULT_LOCALE = "en-US";
+const DEFAULT_CURRENCY = "EUR";
+const DEFAULT_PRICE_FRACTION_DIGITS = 2;
+
+const TIME_UNITS = {
+  y: 31536000000,
+  M: 2592000000,
+  w: 604800000,
+  d: 86400000,
+  h: 3600000,
+  m: 60000,
+  s: 1000,
+  ms: 1,
+} as const;
+
+const TIME_UNIT_ORDER = ["y", "M", "w", "d", "h", "m", "s", "ms"] as const;
+
+type TranslateFunction = (
+  key: string,
+  params?: Record<string, unknown>,
+) => string;
+
+type RelativeTimeRule = {
+  condition: (diffMs: number, targetDate: Date) => boolean;
+  format: (
+    t: TranslateFunction,
+    diffMs: number,
+    targetDate: Date,
+    locale: string,
+  ) => string;
+};
+
+function isSameDay(date1: Date, date2: Date): boolean {
+  return (
+    date1.getFullYear() === date2.getFullYear() &&
+    date1.getMonth() === date2.getMonth() &&
+    date1.getDate() === date2.getDate()
+  );
+}
+
+function formatTimeHHMM(date: Date, locale: string): string {
+  return new Intl.DateTimeFormat(locale, {
+    hour: "2-digit",
+    minute: "2-digit",
+  }).format(date);
+}
+
+function formatShortDate(date: Date, locale: string): string {
+  return new Intl.DateTimeFormat(locale, {
+    day: "2-digit",
+    month: "2-digit",
+    year: "2-digit",
+  }).format(date);
+}
+
+function formatTimeCompact(date: Date): string {
+  const hours = date.getHours();
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  return `${hours}h${minutes}`;
+}
+
+function getYesterday(): Date {
+  const yesterday = new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return yesterday;
+}
+
+const RELATIVE_TIME_RULES: RelativeTimeRule[] = [
+  {
+    condition: (diffMs) => diffMs < TIME_UNITS.m,
+    format: (t) => t("common.time.just_now"),
+  },
+  {
+    condition: (diffMs) => diffMs < TIME_UNITS.h,
+    format: (t, diffMs) =>
+      t("common.time.minutes_ago", {
+        count: Math.floor(diffMs / TIME_UNITS.m),
+      }),
+  },
+  {
+    condition: (diffMs) => diffMs < TIME_UNITS.d,
+    format: (t, diffMs) =>
+      t("common.time.hours_ago", { count: Math.floor(diffMs / TIME_UNITS.h) }),
+  },
+  {
+    condition: (_, targetDate) => isSameDay(targetDate, getYesterday()),
+    format: (t, _, targetDate, locale) =>
+      t("common.time.yesterday_at", {
+        time: formatTimeHHMM(targetDate, locale),
+      }),
+  },
+];
+
+export function formatRelativeTime(
+  date: Date | string | number,
+  t: TranslateFunction,
+  locale: string = DEFAULT_LOCALE,
+): string {
+  const timestamp =
+    date instanceof Date ? date.getTime() : new Date(date).getTime();
+  const targetDate = new Date(timestamp);
+  const diffMs = Date.now() - timestamp;
+
+  for (const rule of RELATIVE_TIME_RULES) {
+    if (rule.condition(diffMs, targetDate)) {
+      return rule.format(t, diffMs, targetDate, locale);
+    }
+  }
+
+  return t("common.time.on_date", {
+    date: `${formatShortDate(targetDate, locale)} ${formatTimeCompact(targetDate)}`,
+  });
+}
+
+const defaultDateFormatterOptions: Intl.DateTimeFormatOptions = {
+  year: "numeric",
+  month: "long",
+  day: "2-digit",
+};
+
+const defaultTimeFormatterOptions: Intl.DateTimeFormatOptions = {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+};
+
+export function formatDate(
+  date: unknown,
+  locale: string = DEFAULT_LOCALE,
+  options?: Intl.DateTimeFormatOptions,
+): string | null {
+  if (date === undefined || date === null) {
+    return null;
+  }
+
+  let validDate: Date;
+  const formatOptions = options || defaultDateFormatterOptions;
+
+  try {
+    if (date instanceof Date) {
+      validDate = date;
+    } else {
+      validDate = new Date(date as string | number);
+    }
+
+    if (Number.isNaN(validDate.getTime())) {
+      return null;
+    }
+
+    return new Intl.DateTimeFormat(locale, formatOptions).format(validDate);
+  } catch {
+    return null;
+  }
+}
+
+export function formatTime(
+  date: Date | string | number | undefined | null,
+  locale: string = DEFAULT_LOCALE,
+  options?: Intl.DateTimeFormatOptions,
+): string | null {
+  return formatDate(date, locale, options || defaultTimeFormatterOptions);
+}
+
+export function formatDateTime(
+  date: Date | string | number | undefined | null,
+  locale: string = DEFAULT_LOCALE,
+  options?: Intl.DateTimeFormatOptions,
+): string | null {
+  return formatDate(date, locale, {
+    ...defaultDateFormatterOptions,
+    ...defaultTimeFormatterOptions,
+    ...options,
+  });
+}
+
+export function formatNumber(
+  value: unknown,
+  locale: string = DEFAULT_LOCALE,
+  options?: Intl.NumberFormatOptions,
+): unknown {
+  if (!isNumber(value)) return value;
+  try {
+    return new Intl.NumberFormat(locale, options).format(value);
+  } catch {
+    return value;
+  }
+}
+
+export function formatPrice(
+  value: unknown,
+  locale: string = DEFAULT_LOCALE,
+  options?: Intl.NumberFormatOptions,
+): unknown {
+  return formatNumber(value, locale, {
+    style: "currency",
+    currency: DEFAULT_CURRENCY,
+    minimumFractionDigits: DEFAULT_PRICE_FRACTION_DIGITS,
+    maximumFractionDigits: DEFAULT_PRICE_FRACTION_DIGITS,
+    ...options,
+  });
+}
+
+export function formatPercentage(
+  value: unknown,
+  locale: string = DEFAULT_LOCALE,
+  options?: Intl.NumberFormatOptions,
+): unknown {
+  return formatNumber(value, locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: DEFAULT_PRICE_FRACTION_DIGITS,
+    ...options,
+  });
+}
+
+export function parseTimeSpan(value: string | number): number {
+  if (isNumber(value)) return Number(value);
+  const normalizedValue = value.trim();
+  if (!normalizedValue) return 0;
+
+  const UNIT_MAP: Record<string, keyof typeof TIME_UNITS> = {
+    y: "y",
+    M: "M",
+    mo: "M",
+    w: "w",
+    d: "d",
+    h: "h",
+    m: "m",
+    s: "s",
+    ms: "ms",
+  };
+
+  let totalMs = 0;
+  const regex = /(\d+(?:\.\d+)?)(ms|mo|[Mmwydhs])/g;
+
+  let match;
+  while ((match = regex.exec(normalizedValue)) !== null) {
+    const rawValue = match[1];
+    const unit = match[2];
+    if (!rawValue || !unit) continue;
+
+    const canonicalUnit = UNIT_MAP[unit];
+    if (!canonicalUnit || !(canonicalUnit in TIME_UNITS)) continue;
+
+    const numValue = Number.parseFloat(rawValue);
+    totalMs += numValue * TIME_UNITS[canonicalUnit as keyof typeof TIME_UNITS];
+  }
+
+  return totalMs;
+}
+
+const DEFAULT_SEPARATOR = ":";
+const ZERO_MS = "0ms";
+
+export function formatTimeSpan(
+  ms: unknown,
+  separator: string = DEFAULT_SEPARATOR,
+): string {
+  if (!isNumber(ms)) return String(ms);
+
+  const totalMs = Number(ms);
+  if (totalMs === 0) return ZERO_MS;
+
+  const parts: string[] = [];
+  let remaining = Math.abs(totalMs);
+
+  for (const unit of TIME_UNIT_ORDER) {
+    const unitValue = TIME_UNITS[unit];
+    if (remaining >= unitValue) {
+      const value = Math.floor(remaining / unitValue);
+      parts.push(`${value}${unit}`);
+      remaining %= unitValue;
+    }
+  }
+
+  const formatted = parts.join(separator);
+  return totalMs < 0 ? `-${formatted}` : formatted;
+}

package/frontend-vue/layers/dms-core/app/utils/http-status.ts

@@ -0,0 +1,8 @@
+export const HTTP_BAD_REQUEST = 400;
+export const HTTP_UNAUTHORIZED = 401;
+export const HTTP_FORBIDDEN = 403;
+export const HTTP_NOT_FOUND = 404;
+export const HTTP_PRECONDITION_FAILED = 412;
+export const HTTP_INTERNAL_SERVER_ERROR = 500;
+
+export const INVALID_REQUEST = "Invalid request";

package/frontend-vue/layers/dms-core/app/utils/menu.ts

@@ -0,0 +1,187 @@
+import type { NavigationMenuItem } from "@nuxt/ui";
+
+// Menu items carry the registered page/category's dot-separated `fullId`
+// (e.g. `pages.erp.orders`) plus the DMS semantic fields; Nuxt UI's
+// NavigationMenuItem type doesn't know about them, so they are read through
+// `DmsMenuItem`.
+
+// Semantic status → theme color, shared by every menu rendering (expanded
+// sidebar icon, collapsed sidebar dot). A dot renders it as `bg-current`, so one
+// map covers both.
+export const MENU_STATUS_TEXT_CLASSES: Record<MenuItemStatus, string> = {
+  success: "text-success",
+  warning: "text-warning",
+  error: "text-error",
+  neutral: "text-dimmed",
+};
+
+export const translateMenuItem = (
+  item: NavigationMenuItem,
+  processI18n: (value: string) => string,
+): NavigationMenuItem => ({
+  ...item,
+  label: item.label ? processI18n(item.label) : undefined,
+  children: item.children
+    ? item.children.map((child) => translateMenuItem(child, processI18n))
+    : undefined,
+});
+
+export const translateMenuItems = (
+  items: NavigationMenuItem[][],
+  processI18n: (value: string) => string,
+): NavigationMenuItem[][] => {
+  return items.map((group) =>
+    group.map((item) => translateMenuItem(item, processI18n)),
+  );
+};
+
+// Whether `item` is the matched page itself or one of its ancestors in the
+// registered category hierarchy. fullId-based to avoid URL-prefix pitfalls:
+// hidden pages still resolve via `findMatchingRoute` and custom-pages can have
+// urlSlugs that escape their parent category's URL.
+export const shouldExpandMenuItem = (
+  item: NavigationMenuItem,
+  matchedFullId: string | null,
+): boolean => {
+  if (!matchedFullId) return false;
+  const fullId = (item as DmsMenuItem).fullId;
+  if (typeof fullId !== "string" || fullId === "") return false;
+  return matchedFullId === fullId || matchedFullId.startsWith(`${fullId}.`);
+};
+
+export const addDefaultOpenToMenuItem = (
+  item: NavigationMenuItem,
+  matchedFullId: string | null,
+): NavigationMenuItem => ({
+  ...item,
+  defaultOpen: item.children
+    ? shouldExpandMenuItem(item, matchedFullId)
+    : undefined,
+  children: item.children?.map((child) =>
+    addDefaultOpenToMenuItem(child, matchedFullId),
+  ),
+});
+
+export const addDefaultOpenToMenuItems = (
+  items: NavigationMenuItem[][],
+  matchedFullId: string | null,
+): NavigationMenuItem[][] => {
+  return items.map((group) =>
+    group.map((item) => addDefaultOpenToMenuItem(item, matchedFullId)),
+  );
+};
+
+const normalizeRoutePath = (path: string): string =>
+  path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+
+// The current route is the link itself or one of its sub-routes. Auto-generated
+// detail views (e.g. `/orders/detail/42`) live under their parent page's URL but
+// are never registered as menu links, so plain route matching would drop the
+// parent's highlight.
+const matchesRoutePrefix = (currentPath: string, to: string): boolean => {
+  const target = normalizeRoutePath(to);
+  const current = normalizeRoutePath(currentPath);
+  if (target === "" || target === "/") return current === target;
+  return current === target || current.startsWith(`${target}/`);
+};
+
+const resolveItemTarget = (
+  to: NavigationMenuItem["to"],
+): MenuItemTarget | null => {
+  if (typeof to === "string") return { path: to };
+  const target = to as MenuItemTarget | undefined;
+  if (target && typeof target.path === "string") {
+    return { path: target.path, query: target.query };
+  }
+  return null;
+};
+
+// Subset match, mirroring the `exactQuery: "partial"` the entries are built
+// with: the entry's own parameters must be the current ones, while unrelated
+// parameters the page adds (tabs, filters) are ignored.
+const queryMatches = (
+  declared: MenuItemTarget["query"],
+  currentQuery: Record<string, unknown>,
+): boolean => {
+  if (!declared) return true;
+  return Object.entries(declared).every(
+    ([key, value]) => currentQuery[key] === value,
+  );
+};
+
+// Whether `item` should be highlighted for the current route. Prefix matching is
+// restricted to leaf links so a page stays highlighted on its auto-generated
+// sub-routes (e.g. `/orders/detail/42`); a parent that carries its own menu
+// children highlights on its exact route only, so it never lights up alongside
+// an active descendant that already has its own entry. The fullId equality
+// fallback covers param routes whose URL never string-matches the `to` pattern.
+// Entries sharing one page through query parameters (`/project?project=<id>`)
+// are told apart by those parameters, so only one of them lights up.
+export const isMenuItemActive = (
+  item: NavigationMenuItem,
+  matchedFullId: string | null,
+  currentRoute: MenuRouteState,
+): boolean => {
+  const target = resolveItemTarget(item.to);
+  if (!target) return false;
+  if (!queryMatches(target.query, currentRoute.query)) return false;
+  const matchesRoute = item.children?.length
+    ? normalizeRoutePath(currentRoute.path) === normalizeRoutePath(target.path)
+    : matchesRoutePrefix(currentRoute.path, target.path);
+  if (matchesRoute) return true;
+  const fullId = (item as DmsMenuItem).fullId;
+  return matchedFullId !== null && fullId === matchedFullId;
+};
+
+// Only the boolean `true` is set: Nuxt UI forwards an explicit `active` to the
+// underlying link, and a `false` there would suppress the built-in route match.
+// Leaving it undefined preserves that native highlighting for every other item.
+export const addActiveStateToMenuItem = (
+  item: NavigationMenuItem,
+  matchedFullId: string | null,
+  currentRoute: MenuRouteState,
+): NavigationMenuItem => ({
+  ...item,
+  ...(isMenuItemActive(item, matchedFullId, currentRoute)
+    ? { active: true }
+    : {}),
+  children: item.children?.map((child) =>
+    addActiveStateToMenuItem(child, matchedFullId, currentRoute),
+  ),
+});
+
+export const addActiveStateToMenuItems = (
+  items: NavigationMenuItem[][],
+  matchedFullId: string | null,
+  currentRoute: MenuRouteState,
+): NavigationMenuItem[][] => {
+  return items.map((group) =>
+    group.map((item) =>
+      addActiveStateToMenuItem(item, matchedFullId, currentRoute),
+    ),
+  );
+};
+
+const collectExpandedIds = (
+  items: NavigationMenuItem[],
+  matchedFullId: string,
+): string[] => {
+  const ids: string[] = [];
+  for (const item of items) {
+    if (item.id && shouldExpandMenuItem(item, matchedFullId)) {
+      ids.push(item.id as string);
+      if (item.children) {
+        ids.push(...collectExpandedIds(item.children, matchedFullId));
+      }
+    }
+  }
+  return ids;
+};
+
+export const getExpandedItemIds = (
+  items: NavigationMenuItem[][],
+  matchedFullId: string | null,
+): string[] => {
+  if (!matchedFullId) return [];
+  return items.flatMap((group) => collectExpandedIds(group, matchedFullId));
+};

package/frontend-vue/layers/dms-core/app/utils/query-validation.ts

@@ -0,0 +1,37 @@
+export function validateRequiredQueryParams(
+  requiredParams: string[] | undefined,
+  queryParams: Record<string, unknown>,
+): boolean {
+  if (!requiredParams || requiredParams.length === 0) {
+    return true;
+  }
+
+  return requiredParams.every((param) => {
+    const value = queryParams[param];
+    return value !== undefined && value !== null && value !== "";
+  });
+}
+
+export interface ValidationRouteContext {
+  query: Record<string, unknown>;
+  params: Record<string, unknown>;
+}
+
+export type ValidationFunction = (route: ValidationRouteContext) => boolean;
+
+export function runCustomValidation(
+  customFunctionId: string | undefined,
+  getFunction: (id: string) => ValidationFunction | undefined,
+  route: ValidationRouteContext,
+): boolean {
+  if (!customFunctionId) {
+    return true;
+  }
+
+  const fn = getFunction(customFunctionId);
+  if (!fn) {
+    return true;
+  }
+
+  return fn(route) === true;
+}

package/frontend-vue/layers/dms-core/app/utils/routePath.ts

@@ -0,0 +1,11 @@
+const QUERY_OR_HASH = /[?#]/;
+
+/**
+ * The path part of a link, dropping its query and hash. Entries of a
+ * query-parameter page share one registered slug, so anything keyed on the
+ * registered route — a prefetch, a layout lookup — keys on this.
+ */
+export function stripQueryAndHash(link: string): string {
+  const [path] = link.split(QUERY_OR_HASH);
+  return path ?? link;
+}

package/frontend-vue/layers/dms-core/app/utils/row-action-rule-evaluator.ts

@@ -0,0 +1,90 @@
+import { get } from "@nuxt/ui/runtime/utils/index.js";
+import type { RowActionRule, RowActionConfig } from "../types/row-action";
+import {
+  FIELD_KEY,
+  FIELD_OPERATORS,
+  LOGICAL_OPERATOR_KEYS,
+} from "../types/row-action-operators";
+
+type RuleEvaluator = (
+  rule: RowActionRule,
+  row: Record<string, unknown>,
+) => boolean;
+
+const createLogicalEvaluators = (evaluate: RuleEvaluator) => ({
+  and: (val: unknown, row: Record<string, unknown>) =>
+    (val as RowActionRule[]).every((r) => evaluate(r, row)),
+  or: (val: unknown, row: Record<string, unknown>) =>
+    (val as RowActionRule[]).some((r) => evaluate(r, row)),
+  not: (val: unknown, row: Record<string, unknown>) =>
+    !evaluate(val as RowActionRule, row),
+});
+
+let cachedLogicalEvaluators: ReturnType<typeof createLogicalEvaluators>;
+const getLogicalEvaluators = () => {
+  if (!cachedLogicalEvaluators) {
+    cachedLogicalEvaluators = createLogicalEvaluators(evaluateRowActionRule);
+  }
+  return cachedLogicalEvaluators;
+};
+
+export const evaluateRowActionRule: RuleEvaluator = (rule, row) => {
+  const ruleObj = rule as Record<string, unknown>;
+  const logicalEvaluators = getLogicalEvaluators();
+
+  for (const operator of LOGICAL_OPERATOR_KEYS) {
+    if (operator in ruleObj) {
+      return logicalEvaluators[operator](ruleObj[operator], row);
+    }
+  }
+
+  if (FIELD_KEY in ruleObj) {
+    const fieldValue = get(row, ruleObj[FIELD_KEY] as string);
+    for (const [operator, def] of Object.entries(FIELD_OPERATORS)) {
+      if (operator in ruleObj) {
+        const compare = def.compare as <T>(a: T, b: T | T[]) => boolean;
+        return compare(fieldValue, ruleObj[operator]);
+      }
+    }
+  }
+
+  return false;
+};
+
+export const normalizeActionConfig = (
+  value: boolean | RowActionConfig | undefined,
+): RowActionConfig => {
+  if (typeof value === "boolean") {
+    return { isEnabled: value };
+  }
+  if (!value) {
+    return { isEnabled: false };
+  }
+  return { isEnabled: true, ...value };
+};
+
+export const isActionEnabled = (
+  value: boolean | RowActionConfig | undefined,
+): boolean => normalizeActionConfig(value).isEnabled ?? false;
+
+export const isActionVisible = (
+  value: boolean | RowActionConfig | undefined,
+): boolean => normalizeActionConfig(value).isVisible === true;
+
+export const createActionValidator = (
+  actionConfig: RowActionConfig,
+  allRows: Record<string, unknown>[],
+  idKey: string,
+) => {
+  const config = normalizeActionConfig(actionConfig);
+
+  return {
+    canPerformAction: (rowId: string): boolean => {
+      if (!config.isEnabled) return false;
+      if (!config.rule) return true;
+
+      const row = allRows.find((r) => get(r, idKey) === rowId);
+      return row ? evaluateRowActionRule(config.rule, row) : false;
+    },
+  };
+};

package/frontend-vue/layers/dms-core/app/utils/stringTypeParser.ts

@@ -0,0 +1,80 @@
+export type Primitive =
+  | string
+  | number
+  | boolean
+  | Date
+  | null
+  | undefined
+  | Record<string, unknown>
+  | unknown[];
+
+const KEYWORD_VALUES = {
+  true: true,
+  false: false,
+  null: null,
+  undefined: undefined,
+};
+
+const PARSER_REGISTRY = [
+  {
+    test: isKeyword,
+    parse: (value: string) =>
+      KEYWORD_VALUES[value as keyof typeof KEYWORD_VALUES],
+  },
+  {
+    test: isStringNumber,
+    parse: (value: string) => Number(value),
+  },
+  {
+    test: isStringDate,
+    parse: (value: string) => new Date(value),
+  },
+  {
+    test: isStringJSON,
+    parse: (value: string) => JSON.parse(value),
+  },
+];
+
+export function parse(value: string): Primitive {
+  for (const parser of PARSER_REGISTRY) {
+    if (parser.test(value)) {
+      return parser.parse(value);
+    }
+  }
+  return value;
+}
+
+export function parseObject(
+  items: Array<{ key: string; value: string }>,
+): Record<string, Primitive> {
+  const result: Record<string, Primitive> = {};
+  for (const item of items) {
+    result[item.key] = parse(item.value);
+  }
+  return result;
+}
+
+export function isKeyword(value: string): boolean {
+  return Object.keys(KEYWORD_VALUES).includes(value);
+}
+
+export function isStringNumber(value: string): boolean {
+  return value !== "" && !Number.isNaN(Number(value));
+}
+
+export function isStringDate(value: string): boolean {
+  if (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z?)?$/.test(value)) {
+    return false;
+  }
+  const date = new Date(value);
+  return !Number.isNaN(date.getTime());
+}
+
+export function isStringJSON(value: string): boolean {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}