@wssto2/vue-core 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 /** The version of @wssto2/vue-core (kept equal to package.json by index.test.ts). */
-export declare const version = "0.2.0";
+export declare const version = "0.4.0";

package/dist/index.js

@@ -1,4 +1,4 @@
-const o = "0.2.0";
+const o = "0.4.0";
 export {
   o as version
 };

package/dist/internal/languageName.d.ts

@@ -0,0 +1,2 @@
+/** A language's name in itself ("hr" is "Hrvatski"), capitalised; the code when the runtime does not know it. */
+export declare function languageName(code: string): string;

package/dist/keepAlive-WYQGRhuz.js

@@ -0,0 +1,48 @@
+function w(a = {}) {
+  const { margin: v = 6e4, retryAfter: m = 3e4 } = a;
+  return {
+    id: "vue-core.keep-session-alive",
+    scope: "session",
+    start({ signal: n, platform: i, report: f }) {
+      let r, s = null;
+      const o = () => {
+        const e = i.session.state.value;
+        return e.status === "authenticated" && e.expiresAt ? e.expiresAt.getTime() - Date.now() - v : null;
+      }, h = () => (s ?? (s = (async () => {
+        try {
+          await a.renew?.(i), await i.session.refresh();
+        } catch (e) {
+          f(e);
+        } finally {
+          s = null;
+        }
+      })()), s);
+      function u(e = 0) {
+        clearTimeout(r);
+        const d = o();
+        d !== null && !n.aborted && (r = setTimeout(() => void t(), Math.min(Math.max(d, e), 864e5)));
+      }
+      async function t() {
+        if (n.aborted || !navigator.onLine) return;
+        const e = o();
+        if (e !== null) {
+          if (e <= 0) {
+            if (await h(), n.aborted) return;
+            u((o() ?? 1) <= 0 ? m : 0);
+            return;
+          }
+          u();
+        }
+      }
+      const c = () => {
+        document.visibilityState === "visible" && t();
+      }, l = () => void t();
+      return document.addEventListener("visibilitychange", c), window.addEventListener("online", l), t(), () => {
+        clearTimeout(r), document.removeEventListener("visibilitychange", c), window.removeEventListener("online", l);
+      };
+    }
+  };
+}
+export {
+  w as k
+};

package/dist/languageName-CItV_SOv.js

@@ -0,0 +1,11 @@
+function e(a) {
+  try {
+    const t = new Intl.DisplayNames([a], { type: "language" }).of(a);
+    return t ? t.charAt(0).toLocaleUpperCase(a) + t.slice(1) : a;
+  } catch {
+    return a;
+  }
+}
+export {
+  e as l
+};

package/dist/languages-BShG9LpE.js

@@ -0,0 +1,10 @@
+import { computed as e } from "vue";
+import { u as p } from "./environment-Dva-SG8D.js";
+import { l as t } from "./languageName-CItV_SOv.js";
+function r() {
+  const o = p();
+  return e(() => o.locales.map((a) => ({ value: a, label: t(a) })));
+}
+export {
+  r as u
+};

package/dist/leaveGuard-Cc8yeLxM.js

@@ -0,0 +1,72 @@
+import { inject as f, onMounted as v, onBeforeUnmount as m, shallowRef as p } from "vue";
+import { matchedRouteKey as h, onBeforeRouteLeave as w, onBeforeRouteUpdate as g } from "vue-router";
+import { d as L } from "./context-Ch1r4fdN.js";
+class G extends Error {
+  constructor() {
+    super(
+      'A page with unsaved changes needs to ask "Discard changes?", but no <LeaveGuardRoot /> is mounted. BackofficeShell renders it; a shell of your own must render <LeaveGuardRoot /> once (import it from @wssto2/vue-core/form).'
+    ), this.name = "MissingLeaveGuardRootError";
+  }
+}
+function R() {
+  const n = p(null), r = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new WeakMap();
+  let t = 0;
+  function o(e = null) {
+    if (t === 0) return Promise.reject(new G());
+    const i = e ? a.get(e) : void 0;
+    if (i) return i;
+    const s = n.value;
+    if (s && e === null && s.to === null) return s.decision;
+    s?.resolve(!1);
+    let c;
+    const u = new Promise((l) => c = l), d = {
+      to: e,
+      decision: u,
+      resolve: (l) => {
+        n.value === d && (n.value = null), c(l);
+      }
+    };
+    return n.value = d, e && a.set(e, u), u;
+  }
+  return {
+    pending: n,
+    confirm: o,
+    attach() {
+      t++;
+      let e = !1;
+      return () => {
+        e || t--, e = !0;
+      };
+    },
+    register(e) {
+      return r.add(e), () => r.delete(e);
+    },
+    hasUnsavedChanges: () => [...r].some((e) => e())
+  };
+}
+const [k, B] = L("vue-core.leaveGuard");
+function U(n) {
+  const r = R();
+  return n.provide(k, r), r;
+}
+function b(n) {
+  const r = B();
+  f(h, null) && (w((o) => n() ? r.confirm(o) : !0), g((o, e) => o.path !== e.path && n() ? r.confirm(o) : !0));
+  function a(o) {
+    n() && (o.preventDefault(), o.returnValue = "");
+  }
+  let t = null;
+  return v(() => {
+    window.addEventListener("beforeunload", a), t = r.register(n);
+  }), m(() => {
+    window.removeEventListener("beforeunload", a), t?.();
+  }), { confirmDiscard: async () => !n() || r.confirm() };
+}
+export {
+  G as M,
+  b as a,
+  R as c,
+  U as i,
+  k as l,
+  B as u
+};

package/dist/modal/Modal.vue.d.ts

@@ -92,8 +92,8 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     } | null;
     title: string;
     size: "sm" | "md" | "lg" | "xl";
-    status: "idle" | "processing" | "done";
     placement: ModalPlacement;
+    status: "idle" | "processing" | "done";
     subtitle: string;
     grouped: boolean;
     withoutFooter: boolean;

package/dist/modal/Sheet.vue.d.ts

@@ -26,6 +26,8 @@ type __VLS_Slots = {
     header?: (scope: {
         titleId: string;
     }) => unknown;
+    /** Buttons in the default header, just before the close button (an inbox's settings gear). */
+    actions?: () => unknown;
 };
 declare function present(): void;
 declare function dismiss(): void;

package/dist/modal/index.js

@@ -1,10 +1,10 @@
-import { _ as G } from "../DiscardChangesModal.vue_vue_type_script_setup_true_lang-DyhYHRyz.js";
-import { _ as y } from "../Modal.vue_vue_type_script_setup_true_lang-BQZM49gC.js";
-import { m as O } from "../Modal.vue_vue_type_script_setup_true_lang-BQZM49gC.js";
-import { _ as T } from "../Sheet.vue_vue_type_script_setup_true_lang-CtkJ-4e3.js";
+import { _ as G } from "../DiscardChangesModal.vue_vue_type_script_setup_true_lang-D1arePCZ.js";
+import { _ as y } from "../Modal.vue_vue_type_script_setup_true_lang-DpBb8ans.js";
+import { m as O } from "../Modal.vue_vue_type_script_setup_true_lang-DpBb8ans.js";
+import { _ as T } from "../Sheet.vue_vue_type_script_setup_true_lang-DgOFV4fa.js";
 import { defineComponent as b, ref as k, computed as v, openBlock as t, createBlock as w, unref as i, withCtx as S, createElementVNode as r, createElementBlock as o, Fragment as c, renderList as u, toDisplayString as l, createCommentVNode as C } from "vue";
 import { useI18n as B } from "vue-i18n";
-import { a as K, u as M } from "../Button.vue_vue_type_script_setup_true_lang-B1eZgLae.js";
+import { a as K, u as M } from "../Button.vue_vue_type_script_setup_true_lang-CL9Qh5yq.js";
 const $ = {
   class: "flex flex-col gap-5",
   "data-test": "shortcut-help"

package/dist/modules/access/entities.d.ts

@@ -0,0 +1,112 @@
+export type BindableRoles = {
+    roles: Role[];
+};
+export type Binding = {
+    id: number;
+    role: RoleSummary;
+    scope: Scope;
+    created_by: PersonRef | null;
+    created_at: string;
+};
+export type Constraint = {
+    attribute: string;
+    values: string[];
+};
+export type EffectiveGrant = {
+    qualifier: string;
+    scope: Scope;
+    attrs: Constraint[];
+    binding_id: number;
+    role_key: string;
+    role_name: string;
+};
+export type EffectivePermission = {
+    permission: string;
+    grants: EffectiveGrant[];
+    unavailable: boolean;
+};
+export type Grant = {
+    permission: string;
+    qualifier: string;
+};
+export type GrantDifference = {
+    permission: string;
+    role: string;
+    other: string;
+};
+export type PersonRef = {
+    id: number;
+    name: string;
+};
+export type Replaced = {
+    rebound: number;
+};
+export type Role = {
+    ref: string;
+    id: number | null;
+    key: string | null;
+    name: string;
+    description: string;
+    predefined: boolean;
+    computed: boolean;
+    attrs: Constraint[];
+    holders: number;
+    permission_count: number;
+    grants: Grant[];
+};
+export type RoleComparison = {
+    only_in_role: Grant[];
+    only_in_other: Grant[];
+    different: GrantDifference[];
+};
+export type RoleHolder = {
+    subject: SubjectRef;
+    name: string;
+    scope: Scope;
+};
+export type RoleHolders = {
+    holders: RoleHolder[];
+};
+export type RoleList = {
+    roles: RoleSummary[];
+};
+export type RoleSummary = {
+    ref: string;
+    id: number | null;
+    key: string | null;
+    name: string;
+    description: string;
+    predefined: boolean;
+    computed: boolean;
+    attrs: Constraint[];
+    holders: number;
+    permission_count: number;
+};
+export type Scope = {
+    level: string;
+    id: number | null;
+    name: string | null;
+};
+export type ScopeOption = {
+    level: string;
+    id: number;
+    name: string;
+    parent_level: string;
+    parent_id: number | null;
+};
+export type ScopeOptions = {
+    root_level: string;
+    root: boolean;
+    places: ScopeOption[];
+};
+export type SubjectAccess = {
+    subject: SubjectRef;
+    bindings: Binding[];
+    effective: EffectivePermission[];
+    can_manage: boolean;
+};
+export type SubjectKind = "user" | "service";
+export type SubjectRef = {
+    kind: SubjectKind;
+    id: number;
+};

package/dist/modules/access/routes.d.ts

@@ -0,0 +1,67 @@
+import type { BindableRoles, Binding, Replaced, Role, RoleComparison, RoleHolders, RoleList, ScopeOptions, SubjectAccess } from "./entities";
+export declare const accessRoutes: {
+    readonly rolesList: import("../../client").ApiRoute<void, RoleList>;
+    readonly rolesShow: import("../../client").ApiRoute<{
+        ref: string;
+    }, Role>;
+    readonly rolesHolders: import("../../client").ApiRoute<{
+        ref: string;
+    }, RoleHolders>;
+    readonly rolesCompare: import("../../client").ApiRoute<{
+        ref: string;
+        with: string;
+    }, RoleComparison>;
+    readonly rolesCreate: import("../../client").ApiRoute<{
+        name: string;
+        description: string;
+        grants: {
+            permission: string;
+            qualifier: string;
+        }[];
+        attrs: {
+            attribute: string;
+            values: string[];
+        }[];
+    }, Role>;
+    readonly rolesUpdate: import("../../client").ApiRoute<{
+        ref: string;
+        name: string;
+        description: string;
+        grants: {
+            permission: string;
+            qualifier: string;
+        }[];
+        attrs: {
+            attribute: string;
+            values: string[];
+        }[];
+    }, Role>;
+    readonly rolesDelete: import("../../client").ApiRoute<{
+        ref: string;
+    }, void>;
+    readonly rolesReplace: import("../../client").ApiRoute<{
+        ref: string;
+        with: string;
+    }, Replaced>;
+    readonly bindable: import("../../client").ApiRoute<{
+        level: string;
+        scope_id: number;
+    }, BindableRoles>;
+    readonly subjectsAccess: import("../../client").ApiRoute<{
+        id: number;
+    }, SubjectAccess>;
+    readonly subjectsScopes: import("../../client").ApiRoute<{
+        id: number;
+    }, ScopeOptions>;
+    readonly subjectsBind: import("../../client").ApiRoute<{
+        id: number;
+        role_ref: string;
+        level: string;
+        scope_id?: number | null | undefined;
+    }, Binding>;
+    readonly subjectsUnbind: import("../../client").ApiRoute<{
+        id: number;
+        binding_id: number;
+    }, void>;
+    readonly me: import("../../client").RawRoute;
+};

package/dist/modules/access/schemas.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+export declare const BindInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    role_ref: z.ZodString;
+    level: z.ZodString;
+    scope_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type BindInput = z.infer<typeof BindInputSchema>;
+export declare const BindableInputSchema: z.ZodObject<{
+    level: z.ZodString;
+    scope_id: z.ZodNumber;
+}, z.core.$strip>;
+export type BindableInput = z.infer<typeof BindableInputSchema>;
+export declare const CompareInputSchema: z.ZodObject<{
+    ref: z.ZodString;
+    with: z.ZodString;
+}, z.core.$strip>;
+export type CompareInput = z.infer<typeof CompareInputSchema>;
+export declare const ConstraintSchema: z.ZodObject<{
+    attribute: z.ZodString;
+    values: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Constraint = z.infer<typeof ConstraintSchema>;
+export declare const GrantInputSchema: z.ZodObject<{
+    permission: z.ZodString;
+    qualifier: z.ZodString;
+}, z.core.$strip>;
+export type GrantInput = z.infer<typeof GrantInputSchema>;
+export declare const CreateRoleInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    grants: z.ZodArray<z.ZodObject<{
+        permission: z.ZodString;
+        qualifier: z.ZodString;
+    }, z.core.$strip>>;
+    attrs: z.ZodArray<z.ZodObject<{
+        attribute: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateRoleInput = z.infer<typeof CreateRoleInputSchema>;
+export declare const ReplaceRoleInputSchema: z.ZodObject<{
+    ref: z.ZodString;
+    with: z.ZodString;
+}, z.core.$strip>;
+export type ReplaceRoleInput = z.infer<typeof ReplaceRoleInputSchema>;
+export declare const RoleInputSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>;
+export type RoleInput = z.infer<typeof RoleInputSchema>;
+export declare const SubjectInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+export type SubjectInput = z.infer<typeof SubjectInputSchema>;
+export declare const UnbindInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    binding_id: z.ZodNumber;
+}, z.core.$strip>;
+export type UnbindInput = z.infer<typeof UnbindInputSchema>;
+export declare const UpdateRoleInputSchema: z.ZodObject<{
+    ref: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    grants: z.ZodArray<z.ZodObject<{
+        permission: z.ZodString;
+        qualifier: z.ZodString;
+    }, z.core.$strip>>;
+    attrs: z.ZodArray<z.ZodObject<{
+        attribute: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UpdateRoleInput = z.infer<typeof UpdateRoleInputSchema>;

package/dist/modules/events/entities.d.ts

@@ -0,0 +1,16 @@
+export type ConsumerNames = {
+    consumers: string[];
+};
+export type DeadLetterRow = {
+    event_id: number;
+    consumer: string;
+    event_name: string;
+    event_created_at: string | null;
+    attempts: number;
+    last_error: string;
+    dead_at: string;
+    retryable: boolean;
+};
+export type Retried = {
+    retried: number;
+};

package/dist/modules/events/routes.d.ts

@@ -0,0 +1,17 @@
+import { type ListResult } from "../../client";
+import type { ConsumerNames, DeadLetterRow, Retried } from "./entities";
+export declare const eventsRoutes: {
+    readonly deadLettersList: import("../../client").ApiRoute<{
+        consumer?: string | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<DeadLetterRow>>;
+    readonly deadLettersRetry: import("../../client").ApiRoute<{
+        event: number;
+        consumer: string;
+    }, Retried>;
+    readonly deadLettersRetryAll: import("../../client").ApiRoute<{
+        consumer: string;
+    }, Retried>;
+    readonly consumers: import("../../client").ApiRoute<void, ConsumerNames>;
+};

package/dist/modules/events/schemas.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const DeadLettersInputSchema: z.ZodObject<{
+    consumer: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DeadLettersInput = z.infer<typeof DeadLettersInputSchema>;
+export declare const RetryAllInputSchema: z.ZodObject<{
+    consumer: z.ZodString;
+}, z.core.$strip>;
+export type RetryAllInput = z.infer<typeof RetryAllInputSchema>;
+export declare const RetryInputSchema: z.ZodObject<{
+    event: z.ZodNumber;
+    consumer: z.ZodString;
+}, z.core.$strip>;
+export type RetryInput = z.infer<typeof RetryInputSchema>;

package/dist/modules/identity/entities.d.ts

@@ -0,0 +1,150 @@
+export type ActivityAction = "created" | "changed" | "deleted";
+export type ActivityRow = {
+    id: number;
+    area: string;
+    record_type: string;
+    record_id: number;
+    action: ActivityAction;
+    signed_in_as: PersonRef | null;
+    created_at: string;
+};
+export type ChangeAction = "created" | "updated" | "deactivated" | "activated" | "password" | "email" | "profile";
+export type ChangeRow = {
+    id: number;
+    action: ChangeAction;
+    fields: string[];
+    before: Record<string, string>;
+    after: Record<string, string>;
+    actor: PersonRef | null;
+    created_at: string;
+};
+export type ChangeView = "all" | "access" | "details";
+export type ClauseInfo = {
+    scope: Scope;
+    qualifier: number;
+    attrs?: Record<string, string[]>;
+    role?: string;
+    binding_id?: number;
+};
+export type Impersonator = {
+    id: number;
+    name: string;
+};
+export type MyAccess = {
+    subject: Subject;
+    root: boolean;
+    permissions: Record<string, PermissionAccess>;
+    unavailable?: string[];
+};
+export type Node = {
+    i18n: string;
+    icon?: string;
+    route?: string;
+    children?: Node[];
+    permissions?: string[];
+};
+export type PendingEmail = {
+    email: string;
+    expires_at: string;
+    resend_available_at: string;
+    attempts_left: number;
+};
+export type PermissionAccess = {
+    scope: Scope;
+    qualifier: number;
+    clauses: ClauseInfo[];
+};
+export type PersonRef = {
+    id: number;
+    name: string;
+};
+export type ProfileResponse = {
+    id: number;
+    login: string;
+    name: string;
+    email: string;
+    phone: string;
+    locale: string;
+    created_at: string;
+    pending_email: PendingEmail | null;
+};
+export type Scope = {
+    level: string;
+    id?: number;
+};
+export type SessionItem = {
+    id: number;
+    device: string;
+    ip: string;
+    opened_by: PersonRef | null;
+    current: boolean;
+    last_used_at: string;
+    expires_at: string;
+    created_at: string;
+};
+export type SessionList = {
+    sessions: SessionItem[];
+};
+export type SessionResponse = {
+    user: unknown;
+    expires_at: string;
+    impersonator?: Impersonator | null;
+    access: MyAccess;
+    navigation?: Node[];
+};
+export type SignInEvent = "signed_in" | "wrong_password" | "locked_out" | "refused_inactive" | "signed_in_as" | "unlocked" | "signed_out_everywhere" | "session_revoked";
+export type SignInRow = {
+    id: number;
+    event: SignInEvent;
+    ip: string;
+    device: string;
+    actor: PersonRef | null;
+    created_at: string;
+};
+export type SignInView = "all" | "failed";
+export type Status = "active" | "locked" | "inactive";
+export type Subject = {
+    kind: string;
+    id: number;
+};
+export type UnlockResult = {
+    unlocked: boolean;
+};
+export type User = {
+    id: number;
+    login: string;
+    name: string;
+    email: string;
+    locale: string;
+};
+export type UserDetail = {
+    id: number;
+    login: string;
+    name: string;
+    email: string;
+    phone: string;
+    locale: string;
+    active: boolean;
+    status: Status;
+    last_sign_in: string | null;
+    locked_until: string | null;
+    created_at: string;
+};
+export type UserRow = {
+    id: number;
+    login: string;
+    name: string;
+    email: string;
+    phone: string;
+    locale: string;
+    active: boolean;
+    status: Status;
+    last_sign_in: string | null;
+    locked_until: string | null;
+    created_at: string;
+};
+export type UserView = "active" | "locked" | "inactive" | "all";
+export type ViewCount = {
+    key: string;
+    count: number;
+};