@revenexx/studio-shared 0.3.0 → 0.3.2

package/dist/runtime/lib/columnOrder.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The order a table's columns are drawn in, once the reader has an opinion.
+ *
+ * Sits beside `columnVisibility` because it has the SAME trap, and the trap has
+ * already shipped once in this file's neighbour.
+ *
+ * A table's column list is not fixed for the life of the component. A tab that
+ * offers Markets only once the service proves it has the column, or engagement
+ * once the deployment reports any, hands the table a LONGER array on a later
+ * render. If the remembered order were treated as the whole truth, every column
+ * that turned up afterwards would be missing from it — and the obvious
+ * implementation, "sort by index in the remembered list, unknowns last", puts
+ * that new column silently at the far right where nobody scrolls. Which is
+ * indistinguishable, from the outside, from never having been built.
+ *
+ * So what is remembered is the reader's own arrangement, and a column that is
+ * not in it keeps its DECLARED neighbours: it lands directly after whichever
+ * declared predecessor is nearest, or first if it has none. A column added
+ * between Channel and Status appears between Channel and Status, wherever the
+ * reader has since dragged those two.
+ */
+export interface OrderableColumn {
+    key: string;
+}
+/**
+ * The declared columns, arranged.
+ *
+ * An empty `order` means the reader has not touched anything, which is not the
+ * same as an order that happens to match — the first is "use the declaration",
+ * the second is a decision that must survive the declaration changing.
+ */
+export declare function orderColumnsBy<T extends OrderableColumn>(columns: readonly T[], order: readonly string[]): T[];
+/**
+ * Move one column and return the arrangement to remember.
+ *
+ * Always a COMPLETE list of keys, even when the previous one was partial or
+ * empty: after the first drag there is an opinion about every column, and a
+ * half-remembered order would leave the untouched ones re-deriving their
+ * position on every render.
+ *
+ * `to` is the index in the list as it will be — what a drop target means — and
+ * out-of-range values clamp rather than throw. A drag that ends outside the
+ * list means "leave it where it is", not "crash the picker".
+ */
+export declare function reorderColumns<T extends OrderableColumn>(columns: readonly T[], order: readonly string[], from: number, to: number): string[];

package/dist/runtime/lib/columnOrder.js

@@ -0,0 +1,28 @@
+export function orderColumnsBy(columns, order) {
+  if (!order.length) return [...columns];
+  const byKey = new Map(columns.map((c) => [c.key, c]));
+  const remembered = new Set(order);
+  const result = order.filter((k) => byKey.has(k)).map((k) => byKey.get(k));
+  columns.forEach((column, declaredIndex) => {
+    if (remembered.has(column.key)) return;
+    let insertAt = 0;
+    for (let i = declaredIndex - 1; i >= 0; i--) {
+      const at = result.indexOf(columns[i]);
+      if (at !== -1) {
+        insertAt = at + 1;
+        break;
+      }
+    }
+    result.splice(insertAt, 0, column);
+  });
+  return result;
+}
+export function reorderColumns(columns, order, from, to) {
+  const keys = orderColumnsBy(columns, order).map((c) => c.key);
+  if (from < 0 || from >= keys.length) return keys;
+  const clamped = Math.max(0, Math.min(to, keys.length - 1));
+  if (clamped === from) return keys;
+  const [moved] = keys.splice(from, 1);
+  keys.splice(clamped, 0, moved);
+  return keys;
+}

package/dist/runtime/lib/columnVisibility.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Which of a DataTable's columns are drawn.
+ *
+ * Pulled out of `DataTable.vue` because the rule has a trap in it that a
+ * component test would not have caught cheaply, and that shipped once already.
+ *
+ * A table's column list is NOT fixed for the life of the component. A tab that
+ * only offers Markets once the service proves it has the column, or a validity
+ * window once the deployment has grown one, hands the table a LONGER array on a
+ * later render than the one it was set up with.
+ *
+ * The table used to seed a set of visible keys once and filter by membership.
+ * Every column that turned up afterwards was therefore missing from that set and
+ * arrived SWITCHED OFF — present in the picker, unticked, and invisible to
+ * everybody who did not go looking. Nobody reports that: from the outside it
+ * looks like the column was never built.
+ *
+ * So what is remembered is the user's own decisions — the columns they ticked
+ * away — and everything else follows its declared default. A column that
+ * appears later gets that default, which is what somebody adding a column
+ * expects and what the previous rule quietly denied them.
+ */
+export interface VisibilityColumn {
+    key: string;
+    /** `false` means "start hidden". Absent means shown. */
+    visible?: boolean;
+}
+/**
+ * The columns hidden before the user has touched anything — the declared
+ * defaults, and nothing else.
+ */
+export declare function initiallyHidden(columns: readonly VisibilityColumn[]): Set<string>;
+/**
+ * The columns to draw: everything except what the user put away.
+ *
+ * Deliberately keyed on hidden rather than on visible. The set of things a
+ * person has decided against is stable; the set of things that exist is not.
+ */
+export declare function visibleColumnsOf<T extends VisibilityColumn>(columns: readonly T[], hidden: ReadonlySet<string>): T[];
+/** Add or remove one column from the user's hidden set. */
+export declare function toggleHidden(hidden: ReadonlySet<string>, key: string): Set<string>;

package/dist/runtime/lib/columnVisibility.js

@@ -0,0 +1,12 @@
+export function initiallyHidden(columns) {
+  return new Set(columns.filter((c) => c.visible === false).map((c) => c.key));
+}
+export function visibleColumnsOf(columns, hidden) {
+  return columns.filter((c) => !hidden.has(c.key));
+}
+export function toggleHidden(hidden, key) {
+  const next = new Set(hidden);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  return next;
+}

package/dist/runtime/lib/dataTableFilters.d.ts

@@ -0,0 +1,83 @@
+/**
+ * What a row's value is for a filter dimension — and why it can be several.
+ *
+ * Pulled out of `DataTable.vue` because the rule underneath it changed shape,
+ * and the change is the kind that reads as harmless and is not.
+ *
+ * ## A row used to belong to exactly one bucket
+ *
+ * `getter: (row) => string` gives every row ONE value per dimension. For status
+ * or channel that is the truth. For anything a row can have several of — the
+ * languages a template is written in, the markets it is scoped to, the tags on
+ * a product — it is not, and the only way to express it was to make the SET the
+ * value:
+ *
+ *   getter: r => r.locales.join(', ')
+ *
+ * which produces a filter menu that reads
+ *
+ *   Deutsch (Deutschland)                                              2
+ *   Deutsch (Deutschland) + British English                           19
+ *   Deutsch (Deutschland) + British English + polski (Polska)          2
+ *   Deutsch (Deutschland) + British English + français + polski        1
+ *   …
+ *
+ * Two things are wrong with that and only one of them is cosmetic.
+ *
+ * The visible one: the options are COMBINATIONS, so the list grows with the
+ * powerset of the values. Four languages produce up to fifteen entries, six up
+ * to sixty-three. No menu, panel or layout survives that.
+ *
+ * The one that matters: "which of these have Polish?" cannot be asked. The
+ * answer is spread across three options, and none of the counts is it. An
+ * operator who picks the option that looks closest gets a confident, wrong
+ * number — the counts adding up to exactly the row total is the tell that this
+ * is a partition rather than a set of overlapping questions.
+ *
+ * ## So a getter may now return an array
+ *
+ * `string | string[] | null | undefined`. A row lands in as many buckets as it
+ * has values, the options become the four languages rather than the fifteen
+ * combinations, and "polski 6" means what it says.
+ *
+ * ## The string path is byte-for-byte what it was
+ *
+ * Deliberately: every existing surface passes a string getter and none of them
+ * should move a pixel. A string — INCLUDING the empty string — is one value,
+ * and `null`/`undefined` still collapse to `''` and count under that key, which
+ * is what the old `String(getter(row) ?? '')` did. Only the array path is new.
+ *
+ * Inside an array, empty entries ARE dropped: a template with no languages
+ * belongs to no language, and letting it pile into a `''` bucket would invent a
+ * silent option nobody declared.
+ *
+ * ## The counts stop summing to the row total, on purpose
+ *
+ * For a multi-valued dimension they now overlap, because a row with three
+ * languages is counted under three of them. That looks like a bug to anybody
+ * who checks the arithmetic, and correcting it would restore exactly the
+ * defect this exists to remove.
+ */
+export type FilterGetter<T> = (row: T) => string | string[] | null | undefined;
+/**
+ * The buckets one row belongs to for one dimension.
+ *
+ * Always an array, so the caller never has to branch on which shape the surface
+ * happened to hand over.
+ */
+export declare function filterValues<T>(getter: FilterGetter<T>, row: T): string[];
+/** How many rows sit in each bucket. Overlapping where a row has several. */
+export declare function countByValue<T>(rows: readonly T[], getter: FilterGetter<T>): Record<string, number>;
+/**
+ * Does a row survive one dimension's active selection?
+ *
+ * `active` may be one value or SEVERAL, because the filter panel that replaced
+ * the old cascading menu lets a reader tick more than one option in a facet.
+ * Several means ANY of them — "Active or Draft", not "Active and Draft", which
+ * is the only reading that can ever match anything: a row has one status.
+ *
+ * Not filtering is `null`, `undefined` or an EMPTY array, and none of those is
+ * the same as filtering on nothing. "All" is the absence of a choice, and a row
+ * whose value happens to be `''` must not be the only thing that survives it.
+ */
+export declare function matchesFilter<T>(getter: FilterGetter<T>, row: T, active: string | readonly string[] | null | undefined): boolean;

package/dist/runtime/lib/dataTableFilters.js

@@ -0,0 +1,23 @@
+export function filterValues(getter, row) {
+  const raw = getter(row);
+  if (Array.isArray(raw)) {
+    return raw.map((v) => String(v ?? "")).filter((v) => v !== "");
+  }
+  return [String(raw ?? "")];
+}
+export function countByValue(rows, getter) {
+  const counts = {};
+  for (const row of rows) {
+    for (const value of filterValues(getter, row)) {
+      counts[value] = (counts[value] ?? 0) + 1;
+    }
+  }
+  return counts;
+}
+export function matchesFilter(getter, row, active) {
+  if (active == null) return true;
+  const wanted = typeof active === "string" ? [active] : active;
+  if (!wanted.length) return true;
+  const values = filterValues(getter, row);
+  return wanted.some((v) => values.includes(v));
+}

package/dist/runtime/lib/i18nBridge.d.ts

@@ -3,13 +3,18 @@ import type { Ref } from 'vue';
 export type TranslateNamed = Record<string, unknown>;
 /**
  * The subset of vue-i18n's `t` the packages are allowed to rely on:
- * `t(key)`, `t(key, named)`, `t(key, plural)`, `t(key, plural, named)`.
+ * `t(key)`, `t(key, named)`, `t(key, plural)`, `t(key, named, plural)`.
+ *
+ * The last one is the order vue-i18n takes for a plural message that also has
+ * placeholders. Its `(key, plural, third)` overload reads the third argument as
+ * `TranslateOptions`, so a bare named bag passed there interpolates nothing —
+ * hence only the named-first form is offered here.
  */
 export interface Translate {
     (key: string): string;
     (key: string, named: TranslateNamed): string;
     (key: string, plural: number): string;
-    (key: string, plural: number, named: TranslateNamed): string;
+    (key: string, named: TranslateNamed, plural: number): string;
 }
 export interface Translator {
     t: Translate;

package/dist/types.d.mts

@@ -16,6 +16,8 @@ export { type TalkbackChannel, type TalkbackChannelOptions, type TalkbackMaybeRe
 
 export { type MediaLibraryClient } from '../dist/runtime/composables/useMediaLibrary.js'
 
+export { type FloatingPanelDock, type FloatingPanelMode, type FloatingPanelOptions } from '../dist/runtime/composables/useFloatingPanel.js'
+
 export { type IsoOption } from '../dist/runtime/lib/isoLists.js'
 
 export { type Translate, type TranslateNamed, type Translator } from '../dist/runtime/lib/i18nBridge.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/studio-shared",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "Shared revenexx Studio shell primitives (PageHeader, SidebarNav, StateCard, DataTable, …) + the platform provider contract (usePlatformAuth/usePlatformTenant). A Nuxt module — add it to `modules`.",
   "main": "./dist/module.mjs",
@@ -28,7 +28,7 @@
     "@nuxt/kit": "^4.0.0"
   },
   "peerDependencies": {
-    "@revenexx/studio": "*",
+    "@revenexx/studio": "^0.2.3",
     "@revenexx/talkback-js": "^0.3.0",
     "@solar-icons/nuxt": "^1.2.0",
     "centrifuge": ">=5.2.0",