@antelopejs/dms 0.11.0 → 0.12.0

package/frontend-vue/layers/dms-ui/app/utils/metadataRetry.ts

@@ -1,7 +1,5 @@
-// Retry policy for reading a stored file's metadata. A refused or missing file
-// will not come back by asking again, so only failures that can heal on their
-// own (network, 5xx, rate limiting) are retried, and with a capped backoff.
-
+import { isObject } from "../../../dms-core/app/utils/type-check";
+import type { apiErrorStatus } from "../../../dms-core/app/composables/useFieldErrors";
 interface FetchFailure {
   statusCode?: number;
   status?: number;
@@ -13,8 +11,11 @@ const CLIENT_ERROR_STATUS_MIN = 400;
 const CLIENT_ERROR_STATUS_MAX = 499;
 const TRANSIENT_CLIENT_STATUSES = new Set([408, 425, 429]);
 
-function failureStatus(error: unknown): number | undefined {
-  if (!error || typeof error !== "object") return undefined;
+function failureStatus(
+  error: Parameters<typeof apiErrorStatus>[0],
+): number | undefined {
+  if (!error || !isObject(error)) return undefined;
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The error owner leaves status fields unchecked. This numeric projection preserves legacy coercive comparisons and nullish precedence; validating the fields would change malformed-input behavior.
   const { statusCode, status } = error as FetchFailure;
   return statusCode ?? status;
 }
@@ -23,7 +24,9 @@ function failureStatus(error: unknown): number | undefined {
  * A 4xx (404 gone, 403 denied, 410…) is the server's final answer about this
  * file; request timeouts and rate limiting are the exceptions that can heal.
  */
-export function isDefinitiveMetadataFailure(error: unknown): boolean {
+export function isDefinitiveMetadataFailure(
+  error: Parameters<typeof apiErrorStatus>[0],
+): boolean {
   const status = failureStatus(error);
   return (
     status !== undefined &&
@@ -38,7 +41,7 @@ export function isDefinitiveMetadataFailure(error: unknown): boolean {
  * when the failure is definitive and the read must not be retried.
  */
 export function resolveMetadataRetryDelay(
-  error: unknown,
+  error: Parameters<typeof apiErrorStatus>[0],
   failedAttempts: number,
 ): number | null {
   if (isDefinitiveMetadataFailure(error)) return null;

package/frontend-vue/layers/dms-ui/app/utils/overlayFocus.ts

@@ -1,5 +1,3 @@
-// Overlays reka-ui dismisses on Escape (modals, slideovers, popovers, menus,
-// selects). They move focus inside themselves while open.
 const OVERLAY_SELECTOR =
   '[role="dialog"], [role="alertdialog"], [role="menu"], [role="listbox"]';
 

package/frontend-vue/layers/dms-ui/app/utils/rowClickAction.ts

@@ -17,7 +17,7 @@ export type RowClickAction = CustomRowAction | "edit" | "details";
 
 const isEnabledForRow = (
   actionConfig: boolean | RowActionConfig | undefined,
-  row: Record<string, unknown>,
+  row: Parameters<typeof evaluateRowActionRule>[1],
 ): boolean => {
   const config = normalizeActionConfig(actionConfig);
   if (!config.isEnabled) return false;
@@ -34,7 +34,7 @@ const isEnabledForRow = (
  */
 export const resolveRowClickAction = (
   rowActions: RowClickActionOptions | undefined,
-  row: Record<string, unknown>,
+  row: Parameters<typeof evaluateRowActionRule>[1],
 ): RowClickAction | undefined => {
   const custom = rowActions?.custom?.find(
     (action) =>
@@ -53,7 +53,7 @@ export const resolveRowClickAction = (
  */
 export const rowCustomActions = (
   custom: CustomRowAction[] | undefined,
-  row: Record<string, unknown>,
+  row: Parameters<typeof evaluateRowActionRule>[1],
 ): CustomRowAction[] =>
   (custom ?? []).filter(
     (action) => !action.rule || evaluateRowActionRule(action.rule, row),

package/frontend-vue/layers/dms-ui/app/utils/semanticTint.ts

@@ -1,8 +1,3 @@
-// Shared design-system semantic colors + the canonical "soft tint" surface
-// (design *-bg ≈ 10% fill) used for icon bubbles, pills and status dots.
-// Tailwind needs literal class strings, so the map is a static record rather
-// than `bg-${c}/10` interpolation. Components with their own per-spec values
-// (e.g. a 20% icon box or a bordered ring) keep those local.
 export type SemanticColor =
   | "success"
   | "error"

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

@@ -281,6 +281,7 @@
       "error_fill_all_fields": "Please fill in all required fields",
       "required_legend": "Required fields",
       "unsaved_changes": "Unsaved changes",
+      "error_not_submitted": "The form was not submitted",
       "fetch_error_title": "Failed to fetch data",
       "fetch_error_unknown": "An unexpected error occurred. Please try again later.",
       "load_error": {

package/frontend-vue/package.json

@@ -11,13 +11,13 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.6.5",
   "engines": {
-    "@antelopejs/dms-frontend": ">=0.9.0 <0.10.0"
+    "@antelopejs/dms-frontend": ">=0.9.1 <0.10.0"
   },
   "scripts": {
     "typecheck": "ajs dms verify-source --layer \"$PWD\" --local-package @antelopejs/dms=.. --local-package @antelopejs/interface-dms=../../interface-dms",
     "test": "vitest run",
     "format": "prettier --write .",
-    "lint": "eslint .",
+    "lint": "node scripts/check-invariants.mjs && node scripts/check-disable-blocks.mjs && eslint .",
     "lint:fix": "eslint . --fix",
     "frontend:build": "ajs dms build -b http://127.0.0.1:5010",
     "frontend:start": "ajs dms start -p 3001"
@@ -79,7 +79,7 @@
   },
   "devDependencies": {
     "@antelopejs/core": ">=1.16.0 <2",
-    "@antelopejs/dms-frontend": ">=0.9.0 <0.10.0",
+    "@antelopejs/dms-frontend": ">=0.9.1 <0.10.0",
     "@eslint/js": "^8.57.0",
     "@inertiajs/vue3": "^3.7.0",
     "@nuxt/ui": "4.10.0",

package/frontend-vue/scripts/check-autoimport-boundaries.mjs

@@ -0,0 +1,277 @@
+import { readFileSync, globSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, relative, resolve, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+import { parse } from "vue/compiler-sfc";
+
+const frontend = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const root = resolve(frontend, "../../..");
+const require = createRequire(import.meta.url);
+const rules = require("../../../../.dependency-cruiser/frontend.cjs").forbidden;
+const importer = createRequire(require.resolve("unplugin-auto-import"));
+const { scanDirExports } = importer("unimport");
+const loader = join(
+  dirname(require.resolve("@antelopejs/dms-frontend/package.json")),
+  "templates/vue/frontend-build-loader.ts",
+);
+const compiled = ts.transpileModule(readFileSync(loader, "utf8"), {
+  compilerOptions: { module: ts.ModuleKind.CommonJS },
+}).outputText;
+const loaderExports = {};
+new Function("require", "exports", compiled)(
+  createRequire(loader),
+  loaderExports,
+);
+const { autoImportDirectories } = loaderExports;
+const declaration = ts.createSourceFile(
+  "build.ts",
+  readFileSync(join(frontend, "dms.frontend.build.ts"), "utf8"),
+  ts.ScriptTarget.Latest,
+  true,
+);
+const directories = [];
+function declared(node) {
+  if (
+    ts.isCallExpression(node) &&
+    ts.isPropertyAccessExpression(node.expression) &&
+    node.expression.name.text === "registerAutoImports"
+  ) {
+    const entries = node.arguments[0];
+    if (
+      !ts.isArrayLiteralExpression(entries) ||
+      !entries.elements.every(ts.isStringLiteral)
+    )
+      throw new Error(
+        "Auto-import audit requires literal declared directories",
+      );
+    directories.push(...entries.elements.map((entry) => entry.text));
+  }
+  ts.forEachChild(node, declared);
+}
+declared(declaration);
+const globs = autoImportDirectories(
+  [{ id: "frontend", root: frontend }],
+  [
+    {
+      id: "frontend",
+      setup: (build) => build.registerAutoImports(directories),
+    },
+  ],
+  (message) => {
+    throw new Error(message);
+  },
+);
+const owners = new Map();
+const components = new Map();
+function own(name, file, registry = owners) {
+  const layer = /\/layers\/dms-([^/]+)\//.exec(file)?.[1];
+  if (!layer) return;
+  const entries = registry.get(name) ?? new Set();
+  entries.add(file);
+  registry.set(name, entries);
+}
+for (const item of await scanDirExports(globs))
+  own(item.as ?? item.name, item.from);
+const registry = ts.createSourceFile(
+  "registry.ts",
+  readFileSync(join(frontend, "dms.frontend.ts"), "utf8"),
+  ts.ScriptTarget.Latest,
+  true,
+);
+const componentGlobs = [];
+const componentAliases = new Map();
+const registryBindings = new Set();
+function registryBinding(file, name) {
+  const key = `${file}:${name}`;
+  if (registryBindings.has(key)) return;
+  registryBindings.add(key);
+  const source = ts.createSourceFile(
+    file,
+    readFileSync(file, "utf8"),
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  const bindings = new Map();
+  const imports = new Map();
+  const declarations = (node) => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name))
+      bindings.set(node.name.text, node.initializer);
+    if (
+      ts.isImportDeclaration(node) &&
+      node.moduleSpecifier.text.startsWith(".")
+    ) {
+      const named = node.importClause?.namedBindings;
+      if (named && ts.isNamedImports(named))
+        for (const item of named.elements)
+          imports.set(item.name.text, {
+            file: resolve(dirname(file), node.moduleSpecifier.text) + ".ts",
+            name: (item.propertyName ?? item.name).text,
+          });
+    }
+    ts.forEachChild(node, declarations);
+  };
+  declarations(source);
+  const expression = (node) => {
+    if (!node) return;
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.getText() === "import.meta.glob"
+    ) {
+      const argument = node.arguments[0];
+      const entries = ts.isArrayLiteralExpression(argument)
+        ? [...argument.elements]
+        : [argument];
+      if (!entries.every(ts.isStringLiteral))
+        throw new Error("Component audit requires literal discovery globs");
+      componentGlobs.push({
+        base: dirname(file),
+        patterns: entries.map((entry) => entry.text),
+      });
+      return;
+    }
+    if (ts.isIdentifier(node)) {
+      const imported = imports.get(node.text);
+      if (imported) registryBinding(imported.file, imported.name);
+      else if (bindings.has(node.text)) registryBinding(file, node.text);
+    }
+    ts.forEachChild(node, expression);
+  };
+  expression(bindings.get(name));
+}
+function registered(node) {
+  if (
+    ts.isVariableDeclaration(node) &&
+    node.name.getText() === "COMPONENT_ALIASES" &&
+    ts.isObjectLiteralExpression(node.initializer)
+  ) {
+    for (const property of node.initializer.properties)
+      if (
+        ts.isPropertyAssignment(property) &&
+        ts.isStringLiteral(property.initializer)
+      )
+        componentAliases.set(
+          property.name.getText(),
+          property.initializer.text,
+        );
+  }
+  ts.forEachChild(node, registered);
+}
+registered(registry);
+registryBinding(join(frontend, "dms.frontend.ts"), "components");
+if (!componentGlobs.length)
+  throw new Error("No component discovery globs found");
+for (const { base, patterns } of componentGlobs)
+  for (const pattern of patterns.filter((entry) => !entry.startsWith("!")))
+    for (const file of globSync(resolve(base, pattern), {
+      exclude: patterns
+        .filter((entry) => entry.startsWith("!"))
+        .map((entry) => resolve(base, entry.slice(1))),
+    })) {
+      const name = basename(file, ".vue")
+        .split(/[._-]+/)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join("");
+      own(name, file, components);
+      if (componentAliases.has(name))
+        own(componentAliases.get(name), file, components);
+    }
+const sources = new Map();
+const templateOffsets = new Map();
+for (const file of globSync(
+  join(frontend, "layers/**/*.{ts,tsx,js,mjs,vue}"),
+)) {
+  if (file.endsWith(".d.ts")) continue;
+  let text = readFileSync(file, "utf8");
+  if (file.endsWith(".vue")) {
+    const { descriptor } = parse(text, { filename: file });
+    const tags = [];
+    const template = (node) => {
+      if (node.type === 1 && node.tagType === 1) tags.push(node.tag);
+      for (const child of node.children ?? []) template(child);
+    };
+    if (descriptor.template?.ast) template(descriptor.template.ast);
+    text = [descriptor.script?.content, descriptor.scriptSetup?.content]
+      .filter(Boolean)
+      .join("\n");
+    templateOffsets.set(file + ".audit.ts", text.length);
+    text +=
+      "\n" +
+      tags
+        .map(
+          (tag) =>
+            `;${
+              tag.includes("-")
+                ? tag
+                    .split("-")
+                    .map((word) => word[0].toUpperCase() + word.slice(1))
+                    .join("")
+                : tag
+            };`,
+        )
+        .join("\n");
+  }
+  sources.set(file + ".audit.ts", text + "\nexport {};");
+}
+const options = { noLib: true, noResolve: true };
+const host = ts.createCompilerHost(options);
+host.getSourceFile = (file, version) =>
+  sources.has(file)
+    ? ts.createSourceFile(file, sources.get(file), version, true)
+    : undefined;
+const program = ts.createProgram([...sources.keys()], options, host);
+const checker = program.getTypeChecker();
+function matches(condition, path) {
+  return (
+    (!condition.path || new RegExp(condition.path).test(path)) &&
+    (!condition.pathNot || !new RegExp(condition.pathNot).test(path))
+  );
+}
+let failures = 0;
+function checkOwner(caller, name, owner) {
+  for (const rule of rules) {
+    if (
+      rule.to.dependencyTypes?.includes("local") ||
+      !matches(rule.from, caller) ||
+      !matches(rule.to, relative(root, owner))
+    )
+      continue;
+    console.error(
+      `FAIL auto-import boundary ${caller} ${rule.name} ${name} -> ${relative(root, owner)}`,
+    );
+    failures++;
+  }
+}
+for (const file of program.getSourceFiles()) {
+  const caller = relative(root, file.fileName.replace(/\.audit\.ts$/, ""));
+  const visit = (node) => {
+    const registry =
+      node.pos >= (templateOffsets.get(file.fileName) ?? Infinity)
+        ? components
+        : owners;
+    if (
+      ts.isIdentifier(node) &&
+      registry.has(node.text) &&
+      !checker.getSymbolAtLocation(node)
+    ) {
+      const parent = node.parent;
+      const property =
+        (ts.isPropertyAccessExpression(parent) ||
+          ts.isPropertyAssignment(parent) ||
+          ts.isMethodDeclaration(parent) ||
+          ts.isPropertySignature(parent)) &&
+        parent.name === node;
+      if (!property)
+        for (const owner of registry.get(node.text)) {
+          checkOwner(caller, node.text, owner);
+        }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+}
+if (failures) process.exitCode = 1;
+else
+  console.log(
+    `PASS frontend generated auto-import and template owners (${owners.size} providers)`,
+  );

package/frontend-vue/scripts/check-disable-blocks.mjs

@@ -0,0 +1,114 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+import { parse } from "vue/compiler-sfc";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const SCRIPT_EXTENSIONS = new Set([
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+]);
+const DIRECTIVE =
+  /^(oxlint|eslint)-(disable|enable)(?:\s+(.*?))?\s*(?:--.*)?$/su;
+
+/** Every comment of a script, each once, in source order. */
+function commentsOf(source, file) {
+  const kind = /\.[jt]sx$/u.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+  const tree = ts.createSourceFile(
+    file,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    kind,
+  );
+  const ranges = new Map();
+  const collect = (node) => {
+    for (const range of [
+      ...(ts.getLeadingCommentRanges(source, node.getFullStart()) ?? []),
+      ...(ts.getTrailingCommentRanges(source, node.getEnd()) ?? []),
+    ])
+      ranges.set(range.pos, range);
+    for (const child of node.getChildren(tree)) collect(child);
+  };
+  collect(tree);
+  return [...ranges.values()]
+    .sort((left, right) => left.pos - right.pos)
+    .map((range) => ({
+      line: tree.getLineAndCharacterOfPosition(range.pos).line + 1,
+      text: source
+        .slice(range.pos, range.end)
+        .replace(/^\/\/|^\/\*|\*\/$/gu, "")
+        .replace(/^\s*\*?\s*/u, "")
+        .trim(),
+    }));
+}
+
+/** The block directives a script leaves open at its end. */
+function unclosedBlocks(source, file, lineOffset) {
+  const open = new Map();
+  const failures = [];
+  for (const { line, text } of commentsOf(source, file)) {
+    const match = DIRECTIVE.exec(text);
+    if (!match) continue;
+    const [, tool, action, list = ""] = match;
+    const rules = list.split(/[\s,]+/u).filter(Boolean);
+    const at = `${file}:${line + lineOffset}`;
+    if (action === "disable") {
+      for (const rule of rules.length ? rules : ["*"])
+        if (!open.has(`${tool} ${rule}`)) open.set(`${tool} ${rule}`, at);
+    } else if (!rules.length) {
+      for (const key of [...open.keys()])
+        if (key.startsWith(`${tool} `)) open.delete(key);
+    } else {
+      for (const rule of rules)
+        if (!open.delete(`${tool} ${rule}`) && !open.has(`${tool} *`))
+          failures.push(
+            `${at}: ${tool}-enable ${rule} closes no ${tool}-disable`,
+          );
+    }
+  }
+  for (const [key, at] of open) {
+    const [tool, rule] = key.split(" ");
+    const named = rule === "*" ? "" : ` ${rule}`;
+    failures.push(
+      `${at}: ${tool}-disable${named} is never closed; add ${tool}-enable${named} right after the code that needs it`,
+    );
+  }
+  return failures;
+}
+
+/** The unclosed block directives of one authored file. */
+function checkFile(file) {
+  const source = readFileSync(join(ROOT, file), "utf8");
+  if (!/(?:oxlint|eslint)-(?:disable|enable)/u.test(source)) return [];
+  if (!file.endsWith(".vue")) return unclosedBlocks(source, file, 0);
+  const { descriptor } = parse(source, { filename: file });
+  return [descriptor.script, descriptor.scriptSetup].flatMap((block) =>
+    block ? unclosedBlocks(block.content, file, block.loc.start.line - 1) : [],
+  );
+}
+
+const files = execFileSync(
+  "git",
+  ["ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+  { cwd: ROOT, encoding: "utf8" },
+)
+  .split("\0")
+  .filter(
+    (file) =>
+      (SCRIPT_EXTENSIONS.has(extname(file)) || file.endsWith(".vue")) &&
+      existsSync(join(ROOT, file)),
+  );
+const failures = files.flatMap(checkFile);
+if (failures.length) {
+  process.stderr.write(`${failures.join("\n")}\n`);
+  process.exitCode = 1;
+}