@antelopejs/dms 0.11.1 → 0.12.1

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

@@ -4,6 +4,7 @@ import {
   regionalDayNumber,
 } from "./regional";
 import { isNumber } from "./type-check";
+import type { I18nTranslate } from "../composables/translation/useTranslation";
 
 const DEFAULT_LOCALE = "en-US";
 const DEFAULT_CURRENCY = "EUR";
@@ -22,7 +23,7 @@ const TIME_UNITS = {
 
 type TranslateFunction = (
   key: string,
-  params?: Record<string, unknown>,
+  params?: Parameters<I18nTranslate>[1],
 ) => string;
 
 type RelativeTimeRule = {
@@ -124,7 +125,6 @@ interface RelativeUnit {
   below: number;
 }
 
-// Months and years by their average length: a distance, not a calendar span.
 const MONTH_MS = 30 * TIME_UNITS.d;
 const YEAR_MS = 365 * TIME_UNITS.d;
 
@@ -179,6 +179,7 @@ const defaultTimeFormatterOptions: Intl.DateTimeFormatOptions = {
 };
 
 export function formatDate(
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Public formatter accepts arbitrary values for Date coercion; Date constructor types exclude supported runtime inputs such as booleans.
   date: unknown,
   locale: string = DEFAULT_LOCALE,
   options?: Intl.DateTimeFormatOptions,
@@ -194,6 +195,7 @@ export function formatDate(
     if (date instanceof Date) {
       validDate = date;
     } else {
+      // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- This is deliberately unchecked Date coercion inside the existing catch; narrowing to constructor parameter types would change accepted inputs.
       validDate = new Date(date as string | number);
     }
 
@@ -252,15 +254,15 @@ export function formatNumber(
   options?: Intl.NumberFormatOptions,
 ): string;
 export function formatNumber(
-  value: unknown,
+  value: Parameters<typeof isNumber>[0],
   locale?: string,
   options?: Intl.NumberFormatOptions,
-): unknown;
+): Parameters<typeof isNumber>[0];
 export function formatNumber(
-  value: unknown,
+  value: Parameters<typeof isNumber>[0],
   locale: string = DEFAULT_LOCALE,
   options?: Intl.NumberFormatOptions,
-): unknown {
+): Parameters<typeof isNumber>[0] {
   if (!isNumber(value)) return value;
   try {
     return readableNumberFormat(locale, options).format(value);
@@ -276,15 +278,15 @@ export function formatPrice(
   options?: Intl.NumberFormatOptions,
 ): string;
 export function formatPrice(
-  value: unknown,
+  value: Parameters<typeof isNumber>[0],
   locale?: string,
   options?: Intl.NumberFormatOptions,
-): unknown;
+): Parameters<typeof isNumber>[0];
 export function formatPrice(
-  value: unknown,
+  value: Parameters<typeof isNumber>[0],
   locale: string = DEFAULT_LOCALE,
   options?: Intl.NumberFormatOptions,
-): unknown {
+): Parameters<typeof isNumber>[0] {
   return formatNumber(value, locale, {
     style: "currency",
     currency: DEFAULT_CURRENCY,
@@ -301,15 +303,15 @@ export function formatPercentage(
   options?: Intl.NumberFormatOptions,
 ): string;
 export function formatPercentage(
-  value: unknown,
+  value: Parameters<typeof isNumber>[0],
   locale?: string,
   options?: Intl.NumberFormatOptions,
-): unknown;
+): Parameters<typeof isNumber>[0];
 export function formatPercentage(
-  value: unknown,
+  value: Parameters<typeof isNumber>[0],
   locale: string = DEFAULT_LOCALE,
   options?: Intl.NumberFormatOptions,
-): unknown {
+): Parameters<typeof isNumber>[0] {
   return formatNumber(value, locale, {
     style: "percent",
     minimumFractionDigits: 0,
@@ -318,7 +320,10 @@ export function formatPercentage(
   });
 }
 
-const TIME_SPAN_UNITS: Record<string, keyof typeof TIME_UNITS> = {
+const TIME_SPAN_UNITS: Record<
+  NonNullable<ReturnType<typeof UNIT_SPAN_PART.exec>>[number],
+  keyof typeof TIME_UNITS
+> = {
   y: "y",
   M: "M",
   mo: "M",
@@ -331,11 +336,10 @@ const TIME_SPAN_UNITS: Record<string, keyof typeof TIME_UNITS> = {
   ms: "ms",
 };
 
-// `01:30`, `8:15`, `26:00:30`: hours, then minutes and seconds under 60.
 const CLOCK_SPAN = /^(\d+):([0-5]\d)(?::([0-5]\d))?$/;
-// `8h15`, `8 h 05`: hours, then bare minutes, the way a time is often written.
+
 const HOUR_MINUTE_SPAN = /^(\d+)\s*h\s*([0-5]?\d)$/i;
-// `1h30m`, `1h 30m`, `7 h 30 min`, `1h:30m` (older displays), `1.5h`.
+
 const UNIT_SPAN = /^(?:\d+(?:[.,]\d+)?\s*(?:ms|mo|min|[Mmwydhs])[\s:]*)+$/;
 const UNIT_SPAN_PART = /(\d+(?:[.,]\d+)?)\s*(ms|mo|min|[Mmwydhs])/g;
 
@@ -389,12 +393,10 @@ export function parseTimeSpan(value: string | number): number {
   return readTimeSpan(value) ?? 0;
 }
 
-// Durations count in hours at most: a day or a month is a calendar span, not
-// a number of hours.
 const DURATION_UNITS = [
   { symbol: "h", ms: TIME_UNITS.h, fractionDigits: 0 },
   { symbol: "min", ms: TIME_UNITS.m, fractionDigits: 0 },
-  // The seconds carry the milliseconds, so nothing is rounded away.
+
   { symbol: "s", ms: TIME_UNITS.s, fractionDigits: 3 },
 ] as const;
 const MS_FRACTION_DIGITS = 3;
@@ -458,7 +460,7 @@ function roundedDuration(ms: number, locale: string): string {
     ms < TIME_UNITS.h
       ? ([TIME_UNITS.m, "min", TIME_UNITS.s, "s"] as const)
       : ([TIME_UNITS.h, "h", TIME_UNITS.m, "min"] as const);
-  // Rounded as a whole first, so 1 min 59.7 s reads "2 min", not "1 min 60 s".
+
   const total = Math.round(ms / minor) * minor;
   const whole = Math.floor(total / major);
   const rest = (total - whole * major) / minor;

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

@@ -1,14 +1,7 @@
 import type { NavigationMenuItem } from "@nuxt/ui";
 import { parseLinkQuery, stripQueryAndHash } from "./routePath";
+import { isString } from "./type-check";
 
-// 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",
@@ -44,27 +37,20 @@ export const translateMenuItems = (
   );
 };
 
-// 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;
+  const dmsItem: DmsMenuItem = item;
+  const fullId = dmsItem.fullId;
+  if (!isString(fullId) || fullId === "") return false;
   return matchedFullId === fullId || matchedFullId.startsWith(`${fullId}.`);
 };
 
 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);
@@ -75,11 +61,12 @@ const matchesRoutePrefix = (currentPath: string, to: string): boolean => {
 const resolveItemTarget = (
   to: NavigationMenuItem["to"],
 ): MenuItemTarget | null => {
-  if (typeof to === "string") {
+  if (isString(to)) {
     return { path: stripQueryAndHash(to), query: parseLinkQuery(to) };
   }
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Preserve the base's unchecked menu projection without widening its public string query contract to router query arrays.
   const target = to as MenuItemTarget | undefined;
-  if (target && typeof target.path === "string") {
+  if (target && isString(target.path)) {
     return { path: target.path, query: target.query };
   }
   return null;
@@ -88,11 +75,9 @@ const resolveItemTarget = (
 const hasQuery = (target: MenuItemTarget | null): boolean =>
   Object.keys(target?.query ?? {}).length > 0;
 
-// Subset match: 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>,
+  currentQuery: MenuRouteState["query"],
 ): boolean => {
   if (!declared) return true;
   return Object.entries(declared).every(
@@ -116,7 +101,8 @@ export const isMenuItemActive = (
         normalizeRoutePath(target.path)
       : matchesRoutePrefix(currentRoute.path, target.path);
   if (matchesRoute) return true;
-  const fullId = (item as DmsMenuItem).fullId;
+  const dmsItem: DmsMenuItem = item;
+  const fullId = dmsItem.fullId;
   return matchedFullId !== null && fullId === matchedFullId;
 };
 
@@ -185,7 +171,7 @@ export const applyMenuRouteState = (
 const collectExpandedIds = (items: NavigationMenuItem[]): string[] => {
   const ids: string[] = [];
   for (const item of items) {
-    if (typeof item.id === "string" && item.defaultOpen) {
+    if (isString(item.id) && item.defaultOpen) {
       ids.push(item.id);
     }
     if (item.children) ids.push(...collectExpandedIds(item.children));

package/frontend-vue/layers/{dms-layout → dms-core}/app/utils/pageQuery.ts

@@ -1,20 +1,18 @@
-// The page URL's query as the server reads it for header-button availability.
+import { isString } from "#dms-core/app/utils/type-check";
 
 /** The page query as the server reads it: one value per name, the last one. */
 export function pageQueryValues(
+  // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- This is the query parsing boundary. Route query types exclude malformed values this public function already discards.
   query: Record<string, unknown> | undefined,
 ): Record<string, string> {
   return Object.fromEntries(
     Object.entries(query ?? {}).flatMap(([name, value]) => {
       const last = Array.isArray(value) ? value.at(-1) : value;
-      return typeof last === "string" ? [[name, last]] : [];
+      return isString(last) ? [[name, last]] : [];
     }),
   );
 }
 
-// Query keys the DMS writes for the view itself, never for the record a page
-// acts on: the row open in a side panel, the paused live mode, and a period
-// selector's range (`<id>.period`, `<id>.compare`, `<id>.from`…).
 const VIEW_STATE_KEYS = new Set(["record", "live"]);
 const PERIOD_KEY = /\.(?:period|compare|from|to|compareFrom|compareTo)$/;
 

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

@@ -1,10 +1,8 @@
-// Mirror of PAGE_ROUTE_PREFIX and pageRoutePath from
-// @antelopejs/interface-dms/page.
-
 /**
  * Where the backend serves the routes a page controller declares, and its
  * layout: under the DMS's own prefix, which the frontend server proxies. The
  * page's own path is the page, never a backend route.
+ * Keep in sync with `PAGE_ROUTE_PREFIX` from `@antelopejs/interface-dms/page`.
  */
 export const PAGE_ROUTE_PREFIX = "/dms/pages";
 
@@ -12,6 +10,8 @@ export const PAGE_ROUTE_PREFIX = "/dms/pages";
  * The backend path of a page's route, as the browser calls it:
  * `pageRoutePath("/settings/user/security", "/sessions")` is
  * `/dms/pages/settings/user/security/sessions`.
+ * Keep its path normalization in sync with `pageRoutePath` from
+ * `@antelopejs/interface-dms/page` so browser requests reach backend routes.
  *
  * @param pageSlug The page's path, such as `/settings/user/security`
  * @param route The route below the page; none for the page's own route

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

@@ -1,6 +1,6 @@
 export function validateRequiredQueryParams(
   requiredParams: string[] | undefined,
-  queryParams: Record<string, unknown>,
+  queryParams: ValidationRouteContext["query"],
 ): boolean {
   if (!requiredParams || requiredParams.length === 0) {
     return true;
@@ -13,8 +13,9 @@ export function validateRequiredQueryParams(
 }
 
 export interface ValidationRouteContext {
+  // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Custom validators own the interpretation of these unparsed values; a router-only value type would narrow the published validation context.
   query: Record<string, unknown>;
-  params: Record<string, unknown>;
+  params: ValidationRouteContext["query"];
 }
 
 export type ValidationFunction = (route: ValidationRouteContext) => boolean;

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

@@ -1,3 +1,5 @@
+import { isString } from "./type-check";
+
 /** `h23`: 24-hour clock (14:05); `h12`: 12-hour clock (2:05 PM). */
 export type TimeFormatPreference = "h23" | "h12";
 
@@ -39,9 +41,9 @@ export interface RegionalOptionsSettings {
 type PreferencesSource = () => RegionalPreferences;
 type ReaderTimeZoneSource = () => string | null | undefined;
 
-const WEEK_STARTS: readonly number[] = [0, 1, 6];
-const TIME_FORMATS: readonly string[] = ["h23", "h12"];
-const DATE_FORMATS: readonly string[] = ["numeric", "text"];
+const WEEK_STARTS: readonly WeekStartPreference[] = [0, 1, 6];
+const TIME_FORMATS: readonly TimeFormatPreference[] = ["h23", "h12"];
+const DATE_FORMATS: readonly DateFormatPreference[] = ["numeric", "text"];
 const TEXT_MONTHS: readonly string[] = ["long", "short", "narrow"];
 const NUMERIC_MONTHS: readonly string[] = ["numeric", "2-digit"];
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -53,18 +55,24 @@ const DAYS_PER_WEEK = 7;
  * texts are British English and French of France (`core-en-GB.json`,
  * `core-fr-FR.json`), while the interface language is the bare tag.
  */
-const DMS_TEXT_LOCALES: Record<string, string> = {
+const DMS_TEXT_LOCALES: Record<
+  Parameters<typeof regionalFormatLocale>[0],
+  ReturnType<typeof regionalFormatLocale>
+> = {
   en: "en-GB",
   fr: "fr-FR",
 };
 
 /** `timeStyle` as the fields it stands for, when a date format replaces `dateStyle`. */
-const TIME_STYLE_FIELDS: Record<string, Intl.DateTimeFormatOptions> = {
+const TIME_STYLE_FIELDS = {
   full: { hour: "2-digit", minute: "2-digit", second: "2-digit" },
   long: { hour: "2-digit", minute: "2-digit", second: "2-digit" },
   medium: { hour: "2-digit", minute: "2-digit", second: "2-digit" },
   short: { hour: "2-digit", minute: "2-digit" },
-};
+} satisfies Record<
+  NonNullable<Intl.DateTimeFormatOptions["timeStyle"]>,
+  Intl.DateTimeFormatOptions
+>;
 
 const NUMERIC_DATE: Intl.DateTimeFormatOptions = {
   day: "2-digit",
@@ -95,8 +103,10 @@ export function browserTimeZone(): string {
   return new Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
 
-const pickFrom = <T>(allowed: readonly unknown[], value: unknown) =>
-  allowed.includes(value) ? (value as T) : undefined;
+const pickFrom = <T>(
+  allowed: readonly T[],
+  value: RegionalPreferenceFields[keyof RegionalPreferenceFields],
+) => allowed.find((candidate) => candidate === value);
 
 /**
  * Keeps the regional preferences of a session user that this runtime can
@@ -107,7 +117,7 @@ export function readRegionalPreferences(
 ): RegionalPreferences {
   if (!fields) return {};
   const timeZone =
-    typeof fields.timeZone === "string" && isKnownTimeZone(fields.timeZone)
+    isString(fields.timeZone) && isKnownTimeZone(fields.timeZone)
       ? fields.timeZone
       : undefined;
   return {
@@ -181,7 +191,7 @@ function toNumericDate(
     return {
       ...rest,
       ...NUMERIC_DATE,
-      ...(timeStyle ? TIME_STYLE_FIELDS[timeStyle] : {}),
+      ...(timeStyle && TIME_STYLE_FIELDS[timeStyle]),
     };
   }
   if (isFullDate(options) && TEXT_MONTHS.includes(options.month ?? "")) {
@@ -302,13 +312,14 @@ type LocaleWithWeekInfo = Intl.Locale & {
  * fr-FR, which both start on Monday.
  */
 export function localeWeekStart(locale: string): number {
+  // prettier-ignore
   try {
-    const info = new Intl.Locale(locale) as LocaleWithWeekInfo;
+    const info: LocaleWithWeekInfo = new Intl.Locale(locale);
     if (!info.region) return MONDAY;
     const weekInfo = info.getWeekInfo?.() ?? info.weekInfo;
     if (weekInfo) return weekInfo.firstDay % DAYS_PER_WEEK;
   } catch {
-    // An unknown tag falls back to Monday.
+    // eslint-disable-line no-empty -- Invalid locale tags fall through to the Monday default.
   }
   return MONDAY;
 }

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

@@ -1,48 +1,31 @@
+import { isBoolean } from "./type-check";
+import type { DataTypeFormatter } from "../composables/data-types/useDataType";
 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";
+import { FIELD_KEY, FIELD_OPERATORS } from "../types/row-action-operators";
 
 type RuleEvaluator = (
   rule: RowActionRule,
-  row: Record<string, unknown>,
+  row: NonNullable<Parameters<DataTypeFormatter>[3]>,
 ) => 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;
-};
+type RuleDictionary = Record<
+  ReturnType<typeof Object.entries>[number][0],
+  Parameters<typeof FIELD_OPERATORS.equals.compare>[0]
+>;
 
 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 ("and" in rule)
+    return rule.and.every((r) => evaluateRowActionRule(r, row));
+  if ("or" in rule) return rule.or.some((r) => evaluateRowActionRule(r, row));
+  if ("not" in rule) return !evaluateRowActionRule(rule.not, row);
 
-  if (FIELD_KEY in ruleObj) {
-    const fieldValue = get(row, ruleObj[FIELD_KEY] as string);
+  if (FIELD_KEY in rule) {
+    const ruleObj: RuleDictionary = rule;
+    const fieldValue = get(row, rule.field);
     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;
+        const compare = def.compare;
         return compare(fieldValue, ruleObj[operator]);
       }
     }
@@ -54,7 +37,7 @@ export const evaluateRowActionRule: RuleEvaluator = (rule, row) => {
 export const normalizeActionConfig = (
   value: boolean | RowActionConfig | undefined,
 ): RowActionConfig => {
-  if (typeof value === "boolean") {
+  if (isBoolean(value)) {
     return { isEnabled: value };
   }
   if (!value) {
@@ -73,7 +56,7 @@ export const isActionVisible = (
 
 export const createActionValidator = (
   actionConfig: RowActionConfig,
-  allRows: Record<string, unknown>[],
+  allRows: Parameters<RuleEvaluator>[1][],
   idKey: string,
 ) => {
   const config = normalizeActionConfig(actionConfig);

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

@@ -5,10 +5,14 @@ export type Primitive =
   | Date
   | null
   | undefined
+  // oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Primitive is the exported parser contract; JSON objects have arbitrary members and a recursive JSON-only replacement would narrow existing consumers of this union.
   | Record<string, unknown>
   | unknown[];
 
-const KEYWORD_VALUES = {
+const KEYWORD_VALUES: Record<
+  Parameters<typeof isKeyword>[0],
+  ReturnType<typeof parse>
+> = {
   true: true,
   false: false,
   null: null,
@@ -18,8 +22,7 @@ const KEYWORD_VALUES = {
 const PARSER_REGISTRY = [
   {
     test: isKeyword,
-    parse: (value: string) =>
-      KEYWORD_VALUES[value as keyof typeof KEYWORD_VALUES],
+    parse: (value: string) => KEYWORD_VALUES[value],
   },
   {
     test: isStringNumber,
@@ -44,9 +47,7 @@ export function parse(value: string): Primitive {
   return value;
 }
 
-export function parseObject(
-  items: Array<{ key: string; value: string }>,
-): Record<string, Primitive> {
+export function parseObject(items: Array<{ key: string; value: string }>) {
   const result: Record<string, Primitive> = {};
   for (const item of items) {
     result[item.key] = parse(item.value);

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

@@ -1,14 +1,17 @@
+// oxlint-disable-next-line anti-slop/no-unknown-returns -- A generic callable guard cannot infer a return contract before the caller invokes the external function.
 type CallableFunction = (...args: any[]) => unknown;
 
 const createTypeGuard =
   <T>(type: string) =>
   (v: unknown): v is T =>
+    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- This primitive boundary guard implements JavaScript typeof semantics; owner types cannot classify unparsed values.
     typeof v === type;
 
 export const isString = createTypeGuard<string>("string");
 export const isNumber = createTypeGuard<number>("number");
 export const isBoolean = createTypeGuard<boolean>("boolean");
 export const isUndefined = createTypeGuard<undefined>("undefined");
+// oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- This exported representation guard has no schema owner; narrowing its values would change the public contract.
 export const isObject = createTypeGuard<Record<string, unknown>>("object");
 export const isFunction = createTypeGuard<CallableFunction>("function");
 export const isBigint = createTypeGuard<bigint>("bigint");
@@ -19,7 +22,7 @@ export const isNull = (value: unknown): value is null => value === null;
 export const isDate = (value: unknown): value is Date =>
   value instanceof Date && !Number.isNaN(value.getTime());
 
-export const isJSON = (value: unknown): boolean => {
+export const isJSON = (value: Parameters<typeof isString>[0]): boolean => {
   if (!isString(value)) {
     return false;
   }

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

@@ -1,57 +1,54 @@
+import type { DataTypeFormatter } from "../composables/data-types/useDataType";
+
 import { get } from "@nuxt/ui/runtime/utils/index.js";
 
-// A row field is named `{{row.<field>}}` (a dotted path reaching into it), as
-// the page's values are `{{params.X}}` / `{{query.X}}`, filled elsewhere.
 const ROW_TOKEN = /\{\{\s*row\.([^{}\s]+)\s*\}\}/g;
-// A template that is one row token and nothing else takes a whole URL from the
-// row (`{{row.invoiceUrl}}`): encoding it would turn its `/` and `?` into
-// `%2F` and `%3F`, leaving no URL to open.
+
 const WHOLE_ROW_TOKEN = new RegExp(`^\\s*${ROW_TOKEN.source}\\s*$`);
 
 /** Whether a template names a field of a row (`{{row.X}}`). */
 export const namesRowField = (template: string): boolean =>
   new RegExp(ROW_TOKEN.source).test(template);
 
-// A relation field is listed as the related row (a join): it stands for that
-// row's id, as the field stores it, rather than "[object Object]". A dotted
-// path (`{{row.customer.name}}`) still reaches into the row.
 const RELATED_ROW_ID_KEYS = ["_id", "id"] as const;
 
-const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+const isPlainObject = (
+  value: Parameters<typeof rowValue>[0][string],
+): value is NonNullable<Parameters<DataTypeFormatter>[3]> =>
   Object.prototype.toString.call(value) === "[object Object]";
 
-const relatedRowId = (value: Record<string, unknown>): unknown =>
+const relatedRowId = (value: NonNullable<Parameters<DataTypeFormatter>[3]>) =>
   RELATED_ROW_ID_KEYS.map((key) => value[key]).find(
     (id) => id !== undefined && id !== null,
   );
 
-const scalarOf = (value: unknown): unknown =>
+const scalarOf = (value: Parameters<typeof rowValue>[0][string]) =>
   isPlainObject(value) ? relatedRowId(value) : value;
 
-const rowValue = (data: Record<string, unknown>, key: string): string => {
+const rowValue = (
+  data: NonNullable<Parameters<DataTypeFormatter>[3]>,
+  key: string,
+): string => {
   const field: unknown = get(data, key);
   const value = Array.isArray(field) ? field.map(scalarOf) : scalarOf(field);
   return value === undefined || value === null ? "" : String(value);
 };
 
-// A colon is a valid path character (RFC 3986 pchar) and the API router
-// matches path parameters without decoding them: tenant-scoped ids
-// ("default:<uuid>") must reach a `/:id/...` route as they are.
 const ENCODED_COLON = /%3A/gi;
 
 const SCHEME_PATTERN = /^\s*([a-z][a-z0-9+.-]*):/i;
 const SAFE_SCHEMES: ReadonlySet<string> = new Set(["http", "https", "mailto"]);
 const REFUSED_URL = "";
 
-// The colon survives the encoding, so a template starting with a field
-// (`{{row.website}}`) takes its scheme from row data: `javascript:` must not reach
-// a link or `location.href`.
 function hasSafeScheme(url: string): boolean {
   const scheme = SCHEME_PATTERN.exec(url)?.[1];
   return scheme === undefined || SAFE_SCHEMES.has(scheme.toLowerCase());
 }
 
-const fillRowTokens = (url: string, data: Record<string, unknown>): string => {
+const fillRowTokens = (
+  url: string,
+  data: NonNullable<Parameters<DataTypeFormatter>[3]>,
+): string => {
   const wholeKey = WHOLE_ROW_TOKEN.exec(url)?.[1];
   if (wholeKey !== undefined) return rowValue(data, wholeKey);
   return url.replace(ROW_TOKEN, (_, key: string) =>
@@ -67,7 +64,7 @@ const fillRowTokens = (url: string, data: Record<string, unknown>): string => {
  */
 export const interpolateUrl = (
   url: string,
-  data: Record<string, unknown>,
+  data: NonNullable<Parameters<DataTypeFormatter>[3]>,
 ): string => {
   const interpolated = fillRowTokens(url, data);
   return hasSafeScheme(interpolated) ? interpolated : REFUSED_URL;
@@ -79,5 +76,5 @@ export const interpolateUrl = (
  */
 export const interpolateRowText = (
   text: string,
-  data: Record<string, unknown>,
+  data: NonNullable<Parameters<DataTypeFormatter>[3]>,
 ): string => text.replace(ROW_TOKEN, (_, key: string) => rowValue(data, key));

package/frontend-vue/layers/dms-core/i18n/locales/core-en-GB.json

@@ -17,6 +17,7 @@
     }
   },
   "error": {
+    "read_only_demo": "Read-only demo, changes are not saved",
     "401": {
       "title": "Access denied",
       "description": "You don't have permission to access this page."

package/frontend-vue/layers/dms-core/i18n/locales/core-fr-FR.json

@@ -17,6 +17,7 @@
     }
   },
   "error": {
+    "read_only_demo": "Démo en lecture seule, les modifications ne sont pas enregistrées",
     "401": {
       "title": "Accès refusé",
       "description": "Vous n'avez pas la permission d'accéder à cette page."