@wssto2/vue-core 0.5.3 → 0.6.0

package/dist/access/index.js

@@ -1,17 +1,49 @@
-import { _ as a, j as c, k as r, c as o, b as u, l as i, m as n, p as l, n as t, q as m, t as p, u as R, i as b, f as d } from "../index-BdGnA1Jh.js";
+import { _ as f, a as R, b } from "../PersonAccess.vue_vue_type_script_setup_true_lang-ClmawvYm.js";
+import { d as o, p as c } from "../feature-DdUAfyi4.js";
+import { a as s, b as t } from "../refusals-COPr15XZ.js";
+import { d as g, p as x, r as h, c as v, u as y, e as C, f as K } from "../refusals-COPr15XZ.js";
+import { d as r } from "../defineRoutes-BGAdiIrt.js";
+const a = r({
+  roles: { name: "access.roles", path: "/iam/roles", component: () => import("../RolesPage-CdYdIHR4.js"), meta: { access: s.viewRoles, titleKey: "core.access.title" } },
+  newRole: { name: "access.roles.new", path: "/iam/roles/new", component: () => import("../NewRolePage-Btg7gzzH.js"), meta: { access: s.manageRoles, titleKey: "core.access.new_title" } },
+  role: {
+    name: "access.role",
+    path: "/iam/roles/:ref",
+    component: () => import("../RolePage-CPlwZA6X.js"),
+    // A role's ref (its key, or the id of a custom one) swaps in place when a link leads to another role.
+    meta: { access: s.viewRoles, titleKey: "core.access.title", remountOnParam: "ref" }
+  }
+}), m = {
+  access: s.viewAccess,
+  section: { labelKey: "core.access.person_roles", icon: "shieldStarFill" }
+};
+function u(e) {
+  return o({
+    id: "access",
+    routes: a.records,
+    context: c(t, {
+      catalogue: e.catalogue,
+      subjectRoute: e.subjectRoute ?? (() => null),
+      constraints: e.roleConstraints ?? [],
+      problems: e.problems ?? {},
+      scopes: e.scopes ?? null
+    }),
+    navigation: e.destination ? [{ destination: e.destination, to: a.roles, within: ["access.role", "access.roles.new"] }] : []
+  });
+}
 export {
-  a as BindingRow,
-  c as PersonAccess,
-  r as accessFeature,
-  o as accessPages,
-  u as accessPermissions,
-  i as accessRoutes,
-  n as dependantsClosure,
-  l as permissionTree,
-  t as personRolesSection,
-  m as requiredClosure,
-  p as roleProblems,
-  R as useAccessLabels,
-  b as useDescribeRefusal,
-  d as useRefusalMessage
+  f as BindingRow,
+  R as PersonAccess,
+  u as accessFeature,
+  a as accessPages,
+  s as accessPermissions,
+  b as accessRoutes,
+  g as dependantsClosure,
+  x as permissionTree,
+  m as personRolesSection,
+  h as requiredClosure,
+  v as roleProblems,
+  y as useAccessLabels,
+  C as useDescribeRefusal,
+  K as useRefusalMessage
 };

package/dist/client/client.d.ts

@@ -38,7 +38,7 @@ export interface HttpClientOptions {
 /** A route that takes no input (`void`, or an empty object) needs no second argument. */
 type RequestArguments<In> = [In] extends [void] ? [input?: undefined, options?: RequestOptions] : [In] extends [Record<string, never>] ? [input?: In, options?: RequestOptions] : [input: In, options?: RequestOptions];
 /** A route declared `void` has no body: its data is `null`. */
-export type RouteResult<Out> = ApiResult<[Out] extends [void] ? null : Out>;
+export type RouteResult<Out, Meta = unknown> = ApiResult<[Out] extends [void] ? null : Out, Meta>;
 export interface HttpClient {
     /**
      * Calls a declared route: `:name` segments of the path are filled from `input` (encoded), the rest of
@@ -46,7 +46,7 @@ export interface HttpClient {
      * parameter rejects with a plain `Error` (a bug in the caller, not an answer from the server) before
      * anything is sent. Abort, request ids and 401 handling are those of `get` and `post`.
      */
-    request<In, Out>(route: ApiRoute<In, Out>, ...args: RequestArguments<In>): Promise<RouteResult<Out>>;
+    request<In, Out, Meta>(route: ApiRoute<In, Out, Meta>, ...args: RequestArguments<In>): Promise<RouteResult<Out, Meta>>;
     get<TData = unknown, TMeta = unknown>(path: string, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
     post<TData = unknown, TMeta = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
     put<TData = unknown, TMeta = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;

package/dist/client/index.d.ts

@@ -8,4 +8,4 @@ export type { ApiErrorInit, ApiErrorKind, FieldErrors } from "./error";
 export { fetchTransport } from "./transport";
 export type { Transport } from "./transport";
 export { route } from "./route";
-export type { HttpMethod, ListResult, RawRoute, ApiRoute, RouteOptions, ViewCount } from "./route";
+export type { HttpMethod, ListResult, PageMeta, RawRoute, ApiRoute, RouteOptions, ViewCount } from "./route";

package/dist/client/route.d.ts

@@ -13,13 +13,18 @@ interface RouteBase {
     readonly permission?: string;
     readonly public: boolean;
 }
-/** A typed call: `In` is what `client.request` takes, `Out` what it resolves to (`void`: no body). */
-export interface ApiRoute<In, Out> extends RouteBase {
+/**
+ * A typed call: `In` is what `client.request` takes, `Out` what it resolves to (`void`: no body), `Meta` the
+ * envelope's top-level `meta` (go-core `route.WithMeta` / `route.Page`). `Meta` defaults to `unknown`, not
+ * `never`: a route that declares none may still be answered with a meta, and `unknown` makes the caller narrow it.
+ */
+export interface ApiRoute<In, Out, Meta = unknown> extends RouteBase {
     readonly raw: false;
     /** Type-only; never set. */
     readonly [types]?: {
         readonly in: In;
         readonly out: Out;
+        readonly meta: Meta;
     };
 }
 /** A route without a JSON answer (an event stream, a file): it keeps method and path for links, `client.request` refuses it. */
@@ -30,8 +35,9 @@ export interface RawRoute extends RouteBase {
  * Declares one endpoint. go-core's generator writes these; the types come from the Go input and response.
  *
  *   route<ShowInput, Ticket>("GET", "/v1/tickets/:id", { permission: "tickets.ticket:view" })
+ *   route<ListInput, Ticket[], PageMeta>("GET", "/v1/tickets")   // a page: `result.meta` is a PageMeta
  */
-export declare function route<In, Out>(method: HttpMethod, path: string, options?: RouteOptions): ApiRoute<In, Out>;
+export declare function route<In, Out, Meta = unknown>(method: HttpMethod, path: string, options?: RouteOptions): ApiRoute<In, Out, Meta>;
 export declare namespace route {
     var raw: (method: HttpMethod, path: string, options?: RouteOptions) => RawRoute;
 }
@@ -40,6 +46,19 @@ export interface ViewCount {
     readonly key: string;
     readonly count: number;
 }
+/**
+ * The `meta` go-core's `web.PageMeta` writes next to a page of rows (`route.Page[T]`); other keys
+ * (lookups, totals) may sit beside these. `readListPage` reads an `ApiResult<Row[], PageMeta>` with no cast.
+ */
+export type PageMeta = Readonly<Record<string, unknown>> & {
+    readonly total: number;
+    readonly page: number;
+    readonly per_page: number;
+    readonly last_page: number;
+    readonly from: number;
+    readonly to: number;
+    readonly views?: readonly ViewCount[];
+};
 /**
  * The wire shape of go-core's `datatable.DatatableResult[T]`: a page of rows with its numbers.
  * `readListPage` (`/collection`) reads it into a `ListPage` with no glue.

package/dist/collection/http.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResult, HttpClient, ListResult, QueryValue } from "../client";
+import type { ApiResult, HttpClient, ListResult, PageMeta, QueryValue } from "../client";
 import type { CollectionLoader, ListPage, CollectionQuery } from "./types";
 /**
  * The query parameters go-core's datatable reads: `page`, `per_page`, `order_col`, `order_dir`,
@@ -8,10 +8,11 @@ export declare function listParams(query: CollectionQuery): Record<string, Query
 /**
  * Reads a list answer into a `ListPage`. Understands go-core's envelope (`data` is the rows,
  * `meta` has `total`, `page`, `per_page`, `last_page`, `from`, `to`, and may carry `views` and lookups)
- * and the shape with the numbers next to `data` (`current_page`), which is `ListResult<Row>`: pass a typed
+ * and the shape with the numbers next to `data` (`current_page`), which is `ListResult<Row>`; a `route.Page` route answers `Row[]` with a `PageMeta`. Pass a typed
  * route's result (`client.request(route, input)`) and `Row` is inferred. Missing numbers are derived
  * from what is there rather than becoming 0; `query` supplies the page and size that were asked for.
  */
+export declare function readListPage<Row>(result: ApiResult<readonly Row[], PageMeta>, query: Pick<CollectionQuery, "page" | "pageSize">): ListPage<Row>;
 export declare function readListPage<Row>(result: ApiResult<ListResult<Row>, unknown>, query: Pick<CollectionQuery, "page" | "pageSize">): ListPage<Row>;
 export declare function readListPage<Row>(result: ApiResult<unknown, unknown>, query: Pick<CollectionQuery, "page" | "pageSize">): ListPage<Row>;
 /**

package/dist/collection/index.js

@@ -1,8 +1,9 @@
-import { D as O, L as j, a as U, h as G, l as X, r as Z } from "../http-CdQowFlW.js";
-import { _ as H, a as J, u as K } from "../CollectionPage.vue_vue_type_script_setup_true_lang-o_Pj-JcD.js";
-import { u as W, a as Y } from "../neighbors-Bv6vnWlW.js";
-import { a as te, b as se } from "../rowLayout-BBFyLbOl.js";
-import { _ as ae } from "../DataTable.vue_vue_type_script_setup_true_lang-BEvz5zqo.js";
+import { D as O, L as j, a as U } from "../state-BC1Fc6U2.js";
+import { _ as X, a as Z, u as q } from "../CollectionPage.vue_vue_type_script_setup_true_lang-DPcCnrjr.js";
+import { h as J, l as K, r as Q } from "../http-nz92KjdS.js";
+import { u as Y, a as ee } from "../neighbors-DNZuGlQH.js";
+import { a as se, b as oe } from "../rowLayout-BBFyLbOl.js";
+import { _ as ne } from "../DataTable.vue_vue_type_script_setup_true_lang-BEvz5zqo.js";
 import { defineComponent as y, openBlock as c, createElementBlock as d, Fragment as h, renderList as v, createBlock as k, unref as f, withCtx as C, normalizeClass as m, createVNode as p, createCommentVNode as g, computed as w, toValue as E } from "vue";
 import { _ } from "../Icon.vue_vue_type_script_lang-D7oC-d-S.js";
 import { _ as S } from "../Tooltip.vue_vue_type_script_setup_true_lang-mErNPt8e.js";
@@ -91,22 +92,22 @@ function V(r, s) {
   }));
 }
 export {
-  te as CollectionCell,
-  H as CollectionPage,
-  J as CollectionTable,
+  se as CollectionCell,
+  X as CollectionPage,
+  Z as CollectionTable,
   B as DATE_PRESETS,
   O as DEFAULT_PAGE_SIZES,
-  ae as DataTable,
+  ne as DataTable,
   j as LIST_CONTEXT_PARAM,
-  se as RecordIdentity,
+  oe as RecordIdentity,
   N as RowActions,
   $ as createMemorySavedViews,
   U as defineCollection,
-  G as httpList,
-  X as listParams,
-  Z as readListPage,
-  K as useCollection,
-  W as useCollectionBack,
-  Y as useCollectionNeighbors,
+  J as httpList,
+  K as listParams,
+  Q as readListPage,
+  q as useCollection,
+  Y as useCollectionBack,
+  ee as useCollectionNeighbors,
   V as useDatePresetFilter
 };