@antelopejs/dms 0.7.11 → 0.7.12

package/frontend-vue/tests/table-live-hold.test.ts

@@ -292,3 +292,93 @@ it("holds the table while its first row is scrolled out of view", async () => {
   expect(refresh).toHaveBeenCalledTimes(2);
   element.remove();
 });
+
+it("holds the table alone while searching or sorted, saying why", async () => {
+  const isSearching = ref(false);
+  const isSorted = ref(false);
+  const isRowOpen = ref(false);
+  const { refresh, hold } = mountTable({
+    liveHold: { whileSearching: true, whileSorted: true, whileRowOpen: true },
+    signals: {
+      isSearching: () => isSearching.value,
+      isSorted: () => isSorted.value,
+      isRowOpen: () => isRowOpen.value,
+    },
+  });
+  expect(hold.reason.value).toBe(null);
+
+  isSorted.value = true;
+  await nextTick();
+  publish();
+  expect(refresh).not.toHaveBeenCalled();
+  expect(hold.reason.value).toBe("sorted");
+
+  isSearching.value = true;
+  await nextTick();
+  expect(hold.reason.value).toBe("searching");
+
+  isRowOpen.value = true;
+  await nextTick();
+  expect(hold.reason.value).toBe("rowOpen");
+
+  // Paused, the page's toggle says why: the table names no reason.
+  live.pause();
+  await nextTick();
+  expect(hold.isHolding.value).toBe(true);
+  expect(hold.reason.value).toBe(null);
+});
+
+it("holds for no search nor sort the options leave off", async () => {
+  const { refresh, hold } = mountTable({
+    liveHold: { whileRowOpen: true },
+    signals: { isSearching: () => true, isSorted: () => true },
+  });
+  publish();
+  expect(refresh).toHaveBeenCalledTimes(1);
+  expect(hold.reason.value).toBe(null);
+});
+
+it("tells the hold about the table's search and sort, and the banner why", () => {
+  expect(tableViewSource).toContain(
+    "isSearching: () => !!effectiveGlobalFilter.value,",
+  );
+  expect(tableViewSource).toContain(
+    "isSorted: () => !isSameSorting(effectiveSorting.value, defaultSortState),",
+  );
+  expect(tableViewSource).toMatch(
+    /v-if="liveHold\.newCount\.value > 0 \|\| liveHold\.reason\.value"/,
+  );
+  expect(tableViewSource).toContain(':reason="liveHold.reason.value"');
+});
+
+it("hands the strip the paused page's breakdown and the table's missedLabel", async () => {
+  const isRowOpen = ref(false);
+  const { hold } = mountTable({
+    liveHold: { whileRowOpen: true, missedLabel: "$api.live.new_requests" },
+    signals: { isRowOpen: () => isRowOpen.value },
+  });
+  expect(hold.missedLabel).toBe("$api.live.new_requests");
+  const detail = { text: "$api.live.in_5xx", params: { count: 1 } };
+
+  // Held by an open row, the page live: the page has no breakdown to give.
+  isRowOpen.value = true;
+  await nextTick();
+  publish();
+  live.setMissedDetail(detail);
+  expect(hold.missedDetail.value).toBe(null);
+
+  live.pause();
+  await nextTick();
+  publish();
+  live.setMissedDetail(detail);
+  expect(hold.missedDetail.value).toEqual(detail);
+
+  live.resume();
+  await nextTick();
+  expect(hold.missedDetail.value).toBe(null);
+});
+
+it("passes the strip its wording and breakdown", () => {
+  expect(tableViewSource).toContain(':missed-label="liveHold.missedLabel"');
+  expect(tableViewSource).toContain(':detail="liveHold.missedDetail.value"');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms",
-  "version": "0.7.11",
+  "version": "0.7.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AntelopeJS/dms.git"
@@ -37,7 +37,7 @@
     "@antelopejs/interface-data-api": ">=0.2.0 <1.0.0",
     "@antelopejs/interface-database": ">=0.1.8 <1.0.0",
     "@antelopejs/interface-database-decorators": ">=0.1.7 <1.0.0",
-    "@antelopejs/interface-dms": ">=0.5.6 <0.6.0",
+    "@antelopejs/interface-dms": ">=0.5.7 <0.6.0",
     "@antelopejs/interface-email": ">=0.0.5 <1.0.0",
     "@antelopejs/interface-file-storage": ">=0.1.3 <1.0.0",
     "archiver": "^7.0.1",

package/skills/dms/SKILL.md

@@ -42,12 +42,21 @@ For the framework underneath (the core, `ajs` CLI, interfaces as versioned contr
   (`slowRateAfter: { period: "7d", maxRate: 60 }` for long periods, `rememberKey: "<module>"` to share the
   choice between pages; `maxRate` is also the polling interval while the stream is down) and places a
   `LiveToggle()` (Live / Pause, L key; `variant: "pill"`, `missedLabel` for "N new requests").
-  `liveHold: true` keeps a table's rows while paused; `liveHold: { whileRowOpen, whileScrolled }` also
-  holds the table alone. Paused, an event counts as its `payload.ids` rows or its `payload.count`, so a
+  `liveHold: true` keeps a table's rows while paused; `liveHold: { whileRowOpen, whileScrolled,
+  whileSearching, whileSorted }` also holds the table alone, its strip saying why ("Table on hold ·
+  search active"); `liveHold.missedLabel` words its "N new", and paused, it adds the
+  `setMissedDetail()` breakdown ("12 new requests · 2 in 5xx"). Paused, an event counts as its `payload.ids` rows or its `payload.count`, so a
   module may batch publishes with `{ count }`. A hidden tab and `?live=0` pause the page too.
   A custom component follows that state with `usePageLive()`, holds the page with `hold(reason)` /
-  `release()` and adds a breakdown with `setMissedDetail()`; `refreshPageBlocks()` (user actions) always
+  `release()` and adds a breakdown with `setMissedDetail()`; a custom component that reads its own data
+  on a topic calls `usePageLiveRefresh(refresh, { realtimeTopic, idleRefresh })`, gated exactly like a
+  built-in block (never a throttle of its own); `refreshPageBlocks()` (user actions) always
   reads, `refreshLivePageBlocks()` (timers, feeds) is held while paused.
+  A custom component on a record page names its record at the end of the breadcrumb with
+  `usePageRecordLabel().setLabel(useDmsRoute().path, label)` (auto-imported; never the `build/` path).
+  A custom component formats through `useRegionalFormat()` (`formatNumber` & co. return `string` for a
+  number); `useRegionalFormat({ locale: "format" })` writes in `formatLocale`, the locale of the DMS's
+  texts (`en` → `en-GB`) — never a hand-rolled `en` → `en-GB` mapping.
   A status the backend computes (health, outage) is a `Banner({ fetchUrl })`: the route answers
   a `BannerContent` (its buttons may run `api` / modal / quick-action targets with `confirm`)
   or `null` for no banner — the block then draws nothing.
@@ -66,6 +75,8 @@ For the framework underneath (the core, `ajs` CLI, interfaces as versioned contr
   duration, an error message), and `DurationDisplay({ format: "ms" })` writes "2,149 ms" on every row;
   and a `PillsDisplay` item may be `{ label, tone?, variant: "soft" | "outline" }`, styled per row.
   A `StatGroup` detail and a `NavCardGrid` card title take up to two lines before their ellipsis.
+  An `ActivityFeed` whose entries must be read whole sets `wrap: true` (no ellipsis; leave `fillHeight`
+  off so the card grows) and `visibleItems: N` for a "Show N more" fold.
   A unit after a number field is `NumberType({ suffix: "$…days" })`, a character counter on a
   text field `StringType({ maxLength, showCount: true })` — no custom `inputComponent` for either.
   A `TableView` over a shared controller hides a column on one page with
@@ -73,8 +84,21 @@ For the framework underneath (the core, `ajs` CLI, interfaces as versioned contr
   just to hide it.
   A long sectioned `Form` groups its navigation with `FormSection.navGroup` ("Billing", "Legal"),
   in the side list and in the `sectionNav: "jump"` chips alike (a form whose side column holds a preview).
+  A module's own `inputComponent` submits its form, adds a validator and focuses a field with
+  `useEnclosingForm()` (never `closest("form")` / `requestSubmit()`), and a link ending in `#<fieldId>`
+  opens the form on that field, focused. `DmsInputNumber` emits `adjust` (`{ typed, value, reason:
+  "min" | "max" | "step" }`) when it keeps another value than the one typed, and redraws the kept
+  value itself: a note "1020 → 1,000" listens to it — never a forced remount (`:key`).
   `TopListCard({ actions })` puts link buttons in its head ("Catalogue →"), and `Tab({ fit: true })`
-  keeps a pill tab list to its tabs' width.
+  keeps a pill tab list to its tabs' width; with `persistState` the URL names the open tab by its slot
+  (`?tab=tester`, an index still read), and a tab `badge` takes a `$` key or a `ComposedText`. A `ChartCard` plotting several series names them with
+  `showSeriesLegend: true` (placed by the chart's `legendPosition: "top" | "bottom"`) — never a raw
+  Apex `legend` in `rawOptions`.
+  A custom component brings a block of its page into view with `scrollToBlock("tabs.statistics")`
+  (the block's key path; `false` when it is not on screen) — never a DOM query of its own.
+  Code in a custom component is a `DmsCodeSnippet` (`language`, `title`, `maxLines` or a CSS
+  `maxHeight`, `wrap: true | "anywhere"`; without title and language its copy button floats in the
+  corner) — never a `<pre>` and copy button of the module's own.
   A `KeyValueList` row takes `copy: true` (a copy button for its shown value) or `copyValue`
   (the text to copy instead, e.g. a full URL behind a short label).
   A table ordered by hand (`reorder: { field }`) moves its rows on the grid and its cards on

package/skills/dms-module/SKILL.md

@@ -93,7 +93,8 @@ Three constraints are enforced at registration: a page's `category` must **desce
 module root** (nest under what `RegisterModule` returned, or rely on `defaultCategory`),
 module pages cannot use the Settings category, and the module must exist before a page names
 it. Pages resolve at `/modules/<moduleId>/<urlSlug>`; entering the module lands on
-`landingPage` if set, else the first page by `order`. Access is **owner-only by design**: the
+`landingPage` if set, else the first page by `order` — `/modules/<id>` itself redirects there (server
+redirect, query and hash kept), so never register a hidden page to forward it. Access is **owner-only by design**: the
 Modules group is visible to the platform owner alone (the `*` holder), and the
 `modules.<moduleId>.…` permission ids are module-scoped — never grantable through Roles. On a
 SaaS deployment that means you, the maker, not your customers; a screen for end users belongs