@wssto2/vue-core 0.1.0 → 0.3.0

package/dist/platform/AccessGate.vue.d.ts

@@ -0,0 +1,50 @@
+import type { Permission } from "./index";
+/** Exactly one of `permission`, `any` or `all`; the others are not allowed, so two requirements cannot be mixed. */
+export type AccessGateProps = {
+    permission: Permission;
+    any?: never;
+    all?: never;
+} | {
+    permission?: never;
+    any: readonly Permission[];
+    all?: never;
+} | {
+    permission?: never;
+    any?: never;
+    all: readonly Permission[];
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{
+    permission: Permission;
+    any?: never;
+    all?: never;
+} | {
+    permission?: never;
+    any: readonly Permission[];
+    all?: never;
+} | {
+    permission?: never;
+    any?: never;
+    all: readonly Permission[];
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    permission: Permission;
+    any?: never;
+    all?: never;
+} | {
+    permission?: never;
+    any: readonly Permission[];
+    all?: never;
+} | {
+    permission?: never;
+    any?: never;
+    all: readonly Permission[];
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+} & {
+    fallback?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/platform/index.d.ts

@@ -9,8 +9,8 @@ export { httpSessionAdapter, parseSessionPayload } from "./httpSession";
 export type { HttpSessionOptions, UserParser } from "./httpSession";
 export { createPlatform, installPlatform, platformKey, usePlatform } from "./platform";
 export type { Platform, PlatformOptions } from "./platform";
-export { beforeSignOutTimeout, createSession } from "./session";
-export type { BeforeSignOutHook, Session, SessionAdapter, SessionEnd, SessionOptions, SessionSnapshot, SessionState, SessionUser } from "./session";
+export { beforeSignOutTimeout, createSession, heldSession } from "./session";
+export type { BeforeSignOutHook, Session, SessionAdapter, SessionEnd, SessionImpersonator, SessionOptions, SessionSnapshot, SessionState, SessionUser } from "./session";
 /**
  * The permission identifiers of the application. The library declares none: an app adds its own by
  * augmenting this interface (declaration merging, like `IconRegistry`), so route metadata and
@@ -24,3 +24,5 @@ export interface PermissionRegistry {
 }
 /** Every permission identifier the application declared; any string until it declares some. */
 export type Permission = keyof PermissionRegistry extends never ? string : Extract<keyof PermissionRegistry, string>;
+export { default as AccessGate } from "./AccessGate.vue";
+export type { AccessGateProps } from "./AccessGate.vue";

package/dist/platform/index.js

@@ -4,28 +4,29 @@ var B = (s) => {
 };
 var E = (s, t, e) => t in s ? N(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
 var $ = (s, t, e) => E(s, typeof t != "symbol" ? t + "" : t, e), w = (s, t, e) => t.has(s) || B("Cannot " + e);
-var o = (s, t, e) => (w(s, t, "read from private field"), e ? e.call(s) : t.get(s)), h = (s, t, e) => t.has(s) ? B("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(s) : t.set(s, e), f = (s, t, e, n) => (w(s, t, "write to private field"), n ? n.call(s, e) : t.set(s, e), e), u = (s, t, e) => (w(s, t, "access private method"), e);
-import { b as J, c as L, a as M, d as T, h as q, i as F, p as K, e as z, f as D, u as G } from "../platform-jqlKVJ2e.js";
+var o = (s, t, e) => (w(s, t, "read from private field"), e ? e.call(s) : t.get(s)), h = (s, t, e) => t.has(s) ? B("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(s) : t.set(s, e), f = (s, t, e, r) => (w(s, t, "write to private field"), r ? r.call(s, e) : t.set(s, e), e), u = (s, t, e) => (w(s, t, "access private method"), e);
+import { b as J, c as L, a as M, d as T, h as q, e as F, i as G, p as K, f as _, g as z, u as D } from "../platform-hunMqFdB.js";
 import { M as Q, d as R } from "../context-Ch1r4fdN.js";
+import { _ as V } from "../AccessGate.vue_vue_type_script_setup_true_lang-DKX3PH2n.js";
 class d extends Error {
-  constructor(e, n = [], r) {
-    super(n.length > 0 ? `${e}: ${n.join("; ")}` : e);
+  constructor(e, r = [], n) {
+    super(r.length > 0 ? `${e}: ${r.join("; ")}` : e);
     $(this, "issues");
     $(this, "cause");
-    this.name = "BootstrapError", this.issues = n, this.cause = r?.cause;
+    this.name = "BootstrapError", this.issues = r, this.cause = n?.cause;
   }
 }
-const x = (s) => s === null ? "null" : Array.isArray(s) ? "array" : typeof s, j = (s) => typeof s == "object" && s !== null && !Array.isArray(s);
+const x = (s) => s === null ? "null" : Array.isArray(s) ? "array" : typeof s, S = (s) => typeof s == "object" && s !== null && !Array.isArray(s);
 var a, c, p, m, l, g;
 const b = class b {
   /** @internal use the `fields` passed to `extend`. */
-  constructor(t, e, n, r = !1) {
+  constructor(t, e, r, n = !1) {
     h(this, l);
     h(this, a);
     h(this, c);
     h(this, p);
     h(this, m);
-    f(this, a, t), f(this, c, e), f(this, p, n), f(this, m, r);
+    f(this, a, t), f(this, c, e), f(this, p, r), f(this, m, n);
   }
   /** Records a problem with `key`; for values `raw` returns that the application validates itself. */
   fail(t, e) {
@@ -36,59 +37,60 @@ const b = class b {
     return o(this, a)[t];
   }
   string(t, ...e) {
-    return u(this, l, g).call(this, t, "string", (n) => typeof n == "string", e);
+    return u(this, l, g).call(this, t, "string", (r) => typeof r == "string", e);
   }
   number(t, ...e) {
-    return u(this, l, g).call(this, t, "number", (n) => typeof n == "number" && Number.isFinite(n), e);
+    return u(this, l, g).call(this, t, "number", (r) => typeof r == "number" && Number.isFinite(r), e);
   }
   boolean(t, ...e) {
-    return u(this, l, g).call(this, t, "boolean", (n) => typeof n == "boolean", e);
+    return u(this, l, g).call(this, t, "boolean", (r) => typeof r == "boolean", e);
   }
   stringList(t, ...e) {
-    return u(this, l, g).call(this, t, "array of strings", (n) => Array.isArray(n) && n.every((r) => typeof r == "string"), e);
+    return u(this, l, g).call(this, t, "array of strings", (r) => Array.isArray(r) && r.every((n) => typeof n == "string"), e);
   }
   /** A nested object, read with the same checks; issues are reported as `parent.child`. */
   section(t) {
     const e = o(this, a)[t];
-    return j(e) ? new b(e, `${o(this, c)}${t}.`, o(this, p)) : (this.fail(t, `expected object, got ${x(e)}`), new b({}, `${o(this, c)}${t}.`, o(this, p), !0));
+    return S(e) ? new b(e, `${o(this, c)}${t}.`, o(this, p)) : (this.fail(t, `expected object, got ${x(e)}`), new b({}, `${o(this, c)}${t}.`, o(this, p), !0));
   }
 };
-a = new WeakMap(), c = new WeakMap(), p = new WeakMap(), m = new WeakMap(), l = new WeakSet(), g = function(t, e, n, r) {
+a = new WeakMap(), c = new WeakMap(), p = new WeakMap(), m = new WeakMap(), l = new WeakSet(), g = function(t, e, r, n) {
   const i = o(this, a)[t];
-  return i === void 0 && r.length > 0 ? r[0] : n(i) ? i : (this.fail(t, `expected ${e}, got ${i === void 0 ? "nothing (missing)" : x(i)}`), null);
+  return i === void 0 && n.length > 0 ? n[0] : r(i) ? i : (this.fail(t, `expected ${e}, got ${i === void 0 ? "nothing (missing)" : x(i)}`), null);
 };
 let A = b;
 function O(s, t) {
-  if (!j(s))
+  if (!S(s))
     throw new d("Invalid bootstrap config", [`expected a JSON object, got ${x(s)}`]);
-  const e = [], n = new A(s, "", e), r = n.string("locale");
-  r === "" && n.fail("locale", "must not be empty");
+  const e = [], r = new A(s, "", e), n = r.string("locale");
+  n === "" && r.fail("locale", "must not be empty");
   const i = {
-    apiBase: n.string("api_base", ""),
-    locale: r,
-    appName: n.string("app_name", null),
-    capabilities: n.stringList("capabilities", [])
-  }, y = t?.(n) ?? {};
+    apiBase: r.string("api_base", ""),
+    locale: n,
+    appName: r.string("app_name", null),
+    capabilities: r.stringList("capabilities", [])
+  }, y = t?.(r) ?? {};
   if (e.length > 0) throw new d("Invalid bootstrap config", e);
   return { ...y, ...i };
 }
 function C(s = {}) {
-  const { element: t = "app-state", extend: e } = s, n = typeof t == "string" ? document.getElementById(t) : t, r = typeof t == "string" ? `#${t}` : "the given element";
-  if (!n)
+  const { element: t = "app-state", extend: e } = s, r = typeof t == "string" ? document.getElementById(t) : t, n = typeof t == "string" ? `#${t}` : "the given element";
+  if (!r)
     throw new d(
-      `Bootstrap config not found: the page has no ${r} element (expected <script id="app-state" type="application/json">)`
+      `Bootstrap config not found: the page has no ${n} element (expected <script id="app-state" type="application/json">)`
     );
-  const i = n.textContent?.trim() ?? "";
-  if (i === "") throw new d(`Bootstrap config is empty: ${r} has no content`);
+  const i = r.textContent?.trim() ?? "";
+  if (i === "") throw new d(`Bootstrap config is empty: ${n} has no content`);
   let y;
   try {
     y = JSON.parse(i);
-  } catch (S) {
-    throw new d(`Bootstrap config in ${r} is not valid JSON`, [], { cause: S });
+  } catch (j) {
+    throw new d(`Bootstrap config in ${n} is not valid JSON`, [], { cause: j });
   }
   return O(y, e);
 }
 export {
+  V as AccessGate,
   d as BootstrapError,
   A as BootstrapFields,
   Q as MissingContextError,
@@ -97,12 +99,13 @@ export {
   M as createPlatform,
   T as createSession,
   R as defineFeatureContext,
-  q as httpSessionAdapter,
-  F as installPlatform,
+  q as heldSession,
+  F as httpSessionAdapter,
+  G as installPlatform,
   O as parseBootstrap,
   K as parseNavigation,
-  z as parseSessionPayload,
-  D as platformKey,
+  _ as parseSessionPayload,
+  z as platformKey,
   C as readBootstrap,
-  G as usePlatform
+  D as usePlatform
 };

package/dist/platform/platform.d.ts

@@ -27,11 +27,11 @@ export interface PlatformOptions<U extends SessionUser, C extends BootstrapConfi
     session?: SessionAdapter<U> | ((http: HttpClient) => SessionAdapter<U>);
     /**
      * Called once when a request is answered 401 while signed in, before the session is given up
-     * (concurrent 401s share one call). Renew it (for example a refresh-token call, then
+     * (concurrent 401s share one call). Renew it with the platform's client (for example a refresh-token call, then
      * `session.refresh()`) and return true: the failed request is sent again. False or a throw expires
      * the session. Without it a 401 expires the session at once.
      */
-    renewSession?: (session: Session<U>) => Promise<boolean>;
+    renewSession?: (session: Session<U>, http: HttpClient) => Promise<boolean>;
     /** Called after a 401 expired a signed-in session: the application decides (usually: go to the login page). */
     onSessionExpired?: () => void;
     /** Called with the failure of a session load or of a before-sign-out hook. */

package/dist/platform/session.d.ts

@@ -5,9 +5,16 @@ import type { NavigationNode } from "./navigation";
 export interface SessionUser {
     readonly id: number | string;
 }
+/** The real person behind a session in which somebody signed in as another (go-core `login-as`). */
+export interface SessionImpersonator {
+    readonly id: number | string;
+    readonly name: string;
+}
 /** What the server says about a session. */
 export interface SessionSnapshot<U extends SessionUser = SessionUser> {
     readonly user: U;
+    /** Set while the user was signed in as by somebody else: who that really is. Absent for a person's own session. */
+    readonly impersonator?: SessionImpersonator;
     /** When the session's access token expires, if the server says; renewing it is the application's effect. */
     readonly expiresAt: Date | null;
     readonly access: AccessSnapshot;
@@ -25,9 +32,12 @@ export type SessionState<U extends SessionUser = SessionUser> =
     readonly status: "unknown";
 } | {
     readonly status: "loading";
-} | {
+}
+/** `previous` is what the session was, kept when it `expired` while someone was working: the page may stay on screen while they sign in again. */
+ | {
     readonly status: "anonymous";
     readonly reason: SessionEnd;
+    readonly previous?: SessionSnapshot<U>;
 } | ({
     readonly status: "authenticated";
 } & SessionSnapshot<U>)
@@ -36,6 +46,11 @@ export type SessionState<U extends SessionUser = SessionUser> =
     readonly status: "failed";
     readonly error: unknown;
 };
+/**
+ * The session as the page around it should still show it: the signed-in one, or the one that just
+ * expired (its user, access and menu stay on screen while the person signs in again); null otherwise.
+ */
+export declare function heldSession<U extends SessionUser>(state: SessionState<U>): SessionSnapshot<U> | null;
 /** The seam to a backend: how to ask who is signed in and how to end the session. */
 export interface SessionAdapter<U extends SessionUser = SessionUser> {
     /** The current session, or null when there is none (not signed in). Reject for failures; honour `signal`. */
@@ -70,6 +85,12 @@ export interface Session<U extends SessionUser = SessionUser> {
      * ends the session on the server; rejects if that call fails. Concurrent calls share one sign-out.
      */
     signOut(): Promise<void>;
+    /**
+     * Whether an expired session keeps what it was (`previous` on the anonymous state), so the page and its shell can
+     * stay on screen while the person signs in again. Off by default; `createApplication` turns it on when a feature
+     * has a prompt for it (`holdsExpiredSession`).
+     */
+    holdExpired(enabled: boolean): void;
     /**
      * Adds a hook `signOut()` runs while the user is still signed in. Returns the function that removes it: a
      * session effect returns it as its stop, so the hook lives exactly as long as the effect.

package/dist/platform-hunMqFdB.js

@@ -0,0 +1,255 @@
+import { c as P } from "./client-Bw0aM5Gu.js";
+import { d as k } from "./context-Ch1r4fdN.js";
+import { a as x, A as q } from "./error-CD7x0Jrz.js";
+import { shallowRef as U } from "vue";
+const _ = (e, n) => e.level === n.level && e.id === n.id, z = (e, n) => Object.prototype.hasOwnProperty.call(e, n);
+function C(e, n = {}) {
+  const t = n.covers ?? _;
+  function o(r) {
+    const s = e();
+    return !s || !z(s.permissions, r) || s.unavailable.includes(r) ? null : s.permissions[r] ?? null;
+  }
+  function a(r, s) {
+    const i = o(r);
+    return i ? s ? (i.clauses.length > 0 ? i.clauses.map((c) => c.scope) : [i.scope]).some((c) => t(c, s)) : !0 : !1;
+  }
+  return {
+    get root() {
+      return e()?.root ?? !1;
+    },
+    can: a,
+    canAny: (r) => r.some((s) => a(s)),
+    canAll: (r) => r.every((s) => a(s)),
+    held: o
+  };
+}
+const A = ["own", "own_location", "all"], m = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function $(e, n, t) {
+  return !m(e) || typeof e.level != "string" ? (t.push(`${n}: expected { level: string, id?: number }`), { level: "" }) : (e.id !== void 0 && typeof e.id != "number" && t.push(`${n}.id: expected number`), typeof e.id == "number" ? { level: e.level, id: e.id } : { level: e.level });
+}
+function S(e, n, t) {
+  return typeof e == "string" && A.includes(e) ? e : (t.push(`${n}: expected one of ${A.join(", ")}`), "own");
+}
+function I(e) {
+  const n = [], t = {}, o = { root: !1, permissions: {}, unavailable: [] };
+  if (!m(e)) return { snapshot: o, issues: ["access: expected an object"] };
+  if (!m(e.permissions)) n.push("access.permissions: expected an object");
+  else
+    for (const [r, s] of Object.entries(e.permissions)) {
+      const i = `access.permissions.${r}`;
+      if (!m(s)) {
+        n.push(`${i}: expected an object`);
+        continue;
+      }
+      const u = (Array.isArray(s.clauses) ? s.clauses : []).map((c, y) => {
+        const l = `${i}.clauses[${y}]`;
+        if (!m(c))
+          return n.push(`${l}: expected an object`), { scope: { level: "" }, qualifier: "own" };
+        const f = { scope: $(c.scope, `${l}.scope`, n), qualifier: S(c.qualifier, `${l}.qualifier`, n) };
+        return typeof c.role == "string" ? { ...f, role: c.role } : f;
+      });
+      t[r] = {
+        scope: $(s.scope, `${i}.scope`, n),
+        qualifier: S(s.qualifier, `${i}.qualifier`, n),
+        clauses: u
+      };
+    }
+  const a = e.unavailable ?? [];
+  return (!Array.isArray(a) || !a.every((r) => typeof r == "string")) && n.push("access.unavailable: expected an array of strings"), {
+    snapshot: {
+      root: e.root === !0,
+      permissions: t,
+      unavailable: Array.isArray(a) ? a.filter((r) => typeof r == "string") : []
+    },
+    issues: n
+  };
+}
+const T = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function j(e, n, t = "navigation") {
+  return Array.isArray(e) ? e.flatMap((o, a) => {
+    const r = `${t}[${a}]`;
+    if (!T(o) || typeof o.i18n != "string")
+      return n.push(`${r}: expected an object with an i18n key`), [];
+    for (const i of ["icon", "route"])
+      o[i] != null && typeof o[i] != "string" && n.push(`${r}.${i}: expected a string`);
+    const s = o.children == null ? void 0 : j(o.children, n, `${r}.children`);
+    return [
+      {
+        i18n: o.i18n,
+        ...typeof o.icon == "string" && { icon: o.icon },
+        ...typeof o.route == "string" && { route: o.route },
+        ...s && { children: s }
+      }
+    ];
+  }) : (n.push(`${t}: expected an array`), []);
+}
+const b = (e) => typeof e == "object" && e !== null && !Array.isArray(e), N = (e) => {
+  if (b(e) && (typeof e.id == "number" || typeof e.id == "string")) return { id: e.id };
+  throw new TypeError("expected an object with a numeric or string id");
+};
+function B(e, n = N) {
+  const t = [];
+  if (!b(e)) throw O(["expected an object"]);
+  let o = null;
+  try {
+    o = n(e.user);
+  } catch (u) {
+    t.push(`user: ${u instanceof Error ? u.message : "invalid"}`);
+  }
+  let a = null;
+  if (e.expires_at !== void 0 && e.expires_at !== null) {
+    const u = typeof e.expires_at == "string" ? new Date(e.expires_at) : null;
+    u === null || Number.isNaN(u.getTime()) ? t.push("expires_at: expected an ISO date-time string") : a = u;
+  }
+  let r;
+  if (e.impersonator !== void 0 && e.impersonator !== null) {
+    const u = e.impersonator;
+    b(u) && (typeof u.id == "number" || typeof u.id == "string") && typeof u.name == "string" ? r = { id: u.id, name: u.name } : t.push("impersonator: expected { id, name }");
+  }
+  const s = I(e.access);
+  t.push(...s.issues);
+  const i = e.navigation === void 0 || e.navigation === null ? void 0 : j(e.navigation, t);
+  if (o === null || t.length > 0) throw O(t);
+  return { user: o, expiresAt: a, access: s.snapshot, ...r && { impersonator: r }, ...i && { navigation: i } };
+}
+const O = (e) => new q({ kind: "malformed", message: `Unreadable session payload: ${e.join("; ")}` });
+function F(e, n = {}) {
+  const { mePath: t = "/auth/me", signOutPath: o = "/auth/logout", parseUser: a } = n;
+  return {
+    async load(r) {
+      try {
+        const { data: s } = await e.get(t, { signal: r, handleUnauthorized: !1 });
+        return B(s, a);
+      } catch (s) {
+        if (x(s) && s.kind === "unauthorized") return null;
+        throw s;
+      }
+    },
+    async signOut() {
+      try {
+        await e.post(o, void 0, { handleUnauthorized: !1 });
+      } catch (r) {
+        if (!(x(r) && r.kind === "unauthorized")) throw r;
+      }
+    }
+  };
+}
+function E(e) {
+  return e.status === "authenticated" ? e : e.status === "anonymous" && e.reason === "expired" ? e.previous ?? null : null;
+}
+const w = 3e3;
+function H(e, n = {}) {
+  const t = U({ status: "unknown" });
+  let o = 0;
+  const a = new Set(n.beforeSignOut ? [n.beforeSignOut] : []);
+  let r = !1, s = null, i = null;
+  function u() {
+    o++, i?.controller.abort(), i = null;
+  }
+  async function c(l) {
+    const f = new AbortController();
+    let h;
+    const g = new Promise((d) => {
+      h = setTimeout(() => {
+        f.abort(), n.onError?.(new Error(`A before-sign-out hook did not finish within ${w} ms; signing out without it.`)), d();
+      }, w);
+    }), v = Promise.all(
+      [...a].map(async (d) => {
+        try {
+          await d(l, f.signal);
+        } catch (p) {
+          n.onError?.(p);
+        }
+      })
+    ).then(() => {
+    });
+    await Promise.race([v, g]), clearTimeout(h);
+  }
+  function y() {
+    if (i) return i.promise;
+    const l = o, f = new AbortController(), h = t.value, g = E(h) !== null;
+    g || (t.value = { status: "loading" });
+    const v = async () => {
+      try {
+        const p = await e.load(f.signal);
+        if (o !== l) return t.value;
+        t.value = p ? { status: "authenticated", ...p } : { status: "anonymous", reason: "none" };
+      } catch (p) {
+        if (o !== l) return t.value;
+        n.onError?.(p), t.value = g ? h : { status: "failed", error: p };
+      } finally {
+        o === l && (i = null);
+      }
+      return t.value;
+    }, d = Promise.resolve().then(v);
+    return i = { controller: f, promise: d }, d;
+  }
+  return {
+    state: t,
+    restore: () => t.value.status === "unknown" || t.value.status === "failed" ? y() : i?.promise ?? Promise.resolve(t.value),
+    refresh: y,
+    establish(l) {
+      u(), t.value = { status: "authenticated", ...l };
+    },
+    expire() {
+      if (t.value.status !== "authenticated") return;
+      const { status: l, ...f } = t.value;
+      u(), t.value = r && !t.value.impersonator ? { status: "anonymous", reason: "expired", previous: f } : { status: "anonymous", reason: "expired" }, n.onExpired?.();
+    },
+    signOut() {
+      return s ?? (s = (async () => {
+        try {
+          const l = t.value;
+          l.status === "authenticated" && a.size > 0 && await c(l.user), u(), t.value = { status: "anonymous", reason: "signedOut" }, await e.signOut();
+        } finally {
+          s = null;
+        }
+      })()), s;
+    },
+    holdExpired(l) {
+      r = l;
+    },
+    onBeforeSignOut(l) {
+      return a.add(l), () => void a.delete(l);
+    }
+  };
+}
+function M(e) {
+  let n = null;
+  const t = P({
+    baseUrl: e.config.apiBase,
+    transport: e.transport,
+    headers: e.headers,
+    credentials: e.credentials,
+    requestId: e.requestId,
+    async onUnauthorized() {
+      return r.state.value.status !== "authenticated" ? "fail" : e.renewSession && (n ?? (n = e.renewSession(r, t).then(
+        (i) => i,
+        () => !1
+      ).finally(() => {
+        n = null;
+      })), await n) ? "retry" : (r.expire(), "fail");
+    }
+  }), o = e.session ?? ((i) => F(i)), a = typeof o == "function" ? o(t) : o, r = H(a, { onError: e.onSessionError, onExpired: e.onSessionExpired, beforeSignOut: e.beforeSignOut }), s = C(
+    () => E(r.state.value)?.access ?? null,
+    { covers: e.covers }
+  );
+  return { config: e.config, http: t, session: r, access: s };
+}
+const [Q, G] = k("platform");
+function J(e, n) {
+  e.provide(Q, n);
+}
+export {
+  M as a,
+  w as b,
+  C as c,
+  H as d,
+  F as e,
+  B as f,
+  Q as g,
+  E as h,
+  J as i,
+  j as p,
+  G as u
+};