@wssto2/vue-core 0.1.0 → 0.3.0

package/dist/modal/index.js

@@ -1,8 +1,66 @@
-import { _ as r } from "../DiscardChangesModal.vue_vue_type_script_setup_true_lang-Bx5O1RZJ.js";
-import { _ as s } from "../Modal.vue_vue_type_script_setup_true_lang-DYQgaUtj.js";
-import { _ as d } from "../Sheet.vue_vue_type_script_setup_true_lang-BLBD5ps8.js";
+import { _ as G } from "../DiscardChangesModal.vue_vue_type_script_setup_true_lang-Cb3xJI1x.js";
+import { _ as y } from "../Modal.vue_vue_type_script_setup_true_lang-D7SwVPpL.js";
+import { m as O } from "../Modal.vue_vue_type_script_setup_true_lang-D7SwVPpL.js";
+import { _ as T } from "../Sheet.vue_vue_type_script_setup_true_lang-bHYzx7-J.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-CYil8h9z.js";
+const $ = {
+  class: "flex flex-col gap-5",
+  "data-test": "shortcut-help"
+}, j = { class: "mb-1 text-footnote font-semibold text-content-muted uppercase" }, D = { class: "divide-y divide-border-separator" }, E = { class: "text-body" }, H = { class: "flex shrink-0 items-center gap-1 text-footnote text-content-muted" }, N = { key: 0 }, V = { class: "text-footnote text-content-muted" }, R = /* @__PURE__ */ b({
+  __name: "ShortcutHelp",
+  setup(z) {
+    const { t: s, te: f } = B(), p = k(null), h = K();
+    M({ key: "?", shiftKey: !0, group: "general", label: () => s("core.shortcuts.show_help") }, () => p.value?.present());
+    const x = v(() => {
+      const a = /* @__PURE__ */ new Map();
+      for (const e of h.value) a.set(e.group ?? "general", [...a.get(e.group ?? "general") ?? [], e]);
+      return [...a].map(([e, n]) => ({ group: e, title: f(`core.shortcuts.groups.${e}`) ? s(`core.shortcuts.groups.${e}`) : e, rows: n }));
+    });
+    return (a, e) => (t(), w(y, {
+      ref_key: "modal",
+      ref: p,
+      title: i(s)("core.shortcuts.title"),
+      size: "sm"
+    }, {
+      default: S(() => [
+        r("div", $, [
+          (t(!0), o(c, null, u(x.value, (n) => (t(), o("section", {
+            key: n.group
+          }, [
+            r("h3", j, l(n.title), 1),
+            r("dl", D, [
+              (t(!0), o(c, null, u(n.rows, (d) => (t(), o("div", {
+                key: d.label,
+                class: "flex items-center justify-between gap-4 py-1.5"
+              }, [
+                r("dt", E, l(d.label), 1),
+                r("dd", H, [
+                  (t(!0), o(c, null, u(d.keys, (m, g) => (t(), o(c, {
+                    key: m.join("+")
+                  }, [
+                    g > 0 ? (t(), o("span", N, l(i(s)("core.shortcuts.or")), 1)) : C("", !0),
+                    (t(!0), o(c, null, u(m, (_) => (t(), o("kbd", {
+                      key: _,
+                      class: "min-w-6 rounded-control border border-border-separator bg-fill px-1.5 py-0.5 text-center font-mono text-content-strong"
+                    }, l(_), 1))), 128))
+                  ], 64))), 128))
+                ])
+              ]))), 128))
+            ])
+          ]))), 128)),
+          r("p", V, l(i(s)("core.shortcuts.hint")), 1)
+        ])
+      ]),
+      _: 1
+    }, 8, ["title"]));
+  }
+});
 export {
-  r as DiscardChangesModal,
-  s as Modal,
-  d as Sheet
+  G as DiscardChangesModal,
+  y as Modal,
+  T as Sheet,
+  R as ShortcutHelp,
+  O as modalPlacementKey
 };

package/dist/modal/placement.d.ts

@@ -0,0 +1,22 @@
+import { type InjectionKey, type MaybeRefOrGetter } from "vue";
+/**
+ * Where a `Modal` stands on wide screens (phones always get the page sheet). The default is the
+ * centre of the viewport. An application shown inside a frame that has chrome of its own (the page
+ * around it covers part of the viewport) aligns dialogs to the top and shifts them away from it.
+ */
+export interface ModalPlacement {
+    /** `"center"` (default) or `"top"`: near the top edge, where a tall dialog does not push its header out of sight. */
+    readonly align?: "center" | "top";
+    /** A horizontal shift in pixels; negative moves the dialog left. Default 0. */
+    readonly offsetX?: number;
+}
+/**
+ * The placement of every modal of the application, once, reactive when given as a ref or getter:
+ *
+ *   app.provide(modalPlacementKey, () => ({ align: "top", offsetX: -hostSidebarWidth.value / 2 }));
+ *
+ * A modal's own `placement` prop wins, field by field.
+ */
+export declare const modalPlacementKey: InjectionKey<MaybeRefOrGetter<ModalPlacement>>;
+/** The placement to apply: the app's, with the modal's own fields on top. */
+export declare function resolvePlacement(app: MaybeRefOrGetter<ModalPlacement> | undefined, own: ModalPlacement | undefined): Required<ModalPlacement>;

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/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;
+};

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

@@ -0,0 +1,118 @@
+import { type ListResult } from "../../client";
+import type { ActivityRow, ChangeRow, PendingEmail, ProfileResponse, SessionList, SessionResponse, SignInRow, UnlockResult, UserDetail, UserRow } from "./entities";
+export declare const identityRoutes: {
+    readonly login: import("../../client").ApiRoute<{
+        login: string;
+        password: string;
+    }, SessionResponse>;
+    readonly refresh: import("../../client").ApiRoute<{
+        refresh_token: string;
+    }, SessionResponse>;
+    readonly logout: import("../../client").ApiRoute<void, void>;
+    readonly me: import("../../client").ApiRoute<void, SessionResponse>;
+    readonly changeLocale: import("../../client").ApiRoute<{
+        locale: string;
+    }, void>;
+    readonly loginAs: import("../../client").ApiRoute<{
+        user_id: number;
+    }, SessionResponse>;
+    readonly loginAsReturn: import("../../client").ApiRoute<void, SessionResponse>;
+    readonly usersList: import("../../client").ApiRoute<{
+        view?: "inactive" | "all" | "locked" | "active" | undefined;
+        search?: string | undefined;
+        order_col?: string | undefined;
+        order_dir?: string | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<UserRow>>;
+    readonly usersShow: import("../../client").ApiRoute<{
+        id: number;
+    }, UserDetail>;
+    readonly usersCreate: import("../../client").ApiRoute<{
+        login: string;
+        name: string;
+        email: string;
+        locale: string;
+        password: string;
+        phone?: string | undefined;
+    }, UserDetail>;
+    readonly usersUpdate: import("../../client").ApiRoute<{
+        id: number;
+        login: string;
+        name: string;
+        email: string;
+        locale: string;
+        phone?: string | undefined;
+    }, UserDetail>;
+    readonly usersSetPassword: import("../../client").ApiRoute<{
+        id: number;
+        password: string;
+    }, void>;
+    readonly usersDeactivate: import("../../client").ApiRoute<{
+        id: number;
+    }, void>;
+    readonly usersActivate: import("../../client").ApiRoute<{
+        id: number;
+    }, void>;
+    readonly usersUnlock: import("../../client").ApiRoute<{
+        id: number;
+    }, UnlockResult>;
+    readonly usersSignins: import("../../client").ApiRoute<{
+        id: number;
+        view?: "all" | "failed" | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<SignInRow>>;
+    readonly usersChanges: import("../../client").ApiRoute<{
+        id: number;
+        view?: "details" | "all" | "access" | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<ChangeRow>>;
+    readonly usersActivity: import("../../client").ApiRoute<{
+        id: number;
+        area?: string | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<ActivityRow>>;
+    readonly usersSessions: import("../../client").ApiRoute<{
+        id: number;
+    }, SessionList>;
+    readonly usersRevokeSession: import("../../client").ApiRoute<{
+        id: number;
+        session_id: number;
+    }, void>;
+    readonly usersRevokeSessions: import("../../client").ApiRoute<{
+        id: number;
+    }, void>;
+    readonly profileShow: import("../../client").ApiRoute<void, ProfileResponse>;
+    readonly profileUpdate: import("../../client").ApiRoute<{
+        name: string;
+        phone?: string | undefined;
+    }, ProfileResponse>;
+    readonly profileChangePassword: import("../../client").ApiRoute<{
+        current_password: string;
+        new_password: string;
+        new_password_confirmation: string;
+    }, void>;
+    readonly profileRequestEmail: import("../../client").ApiRoute<{
+        email: string;
+        current_password: string;
+    }, PendingEmail>;
+    readonly profileResendEmail: import("../../client").ApiRoute<void, PendingEmail>;
+    readonly profileConfirmEmail: import("../../client").ApiRoute<{
+        code: string;
+    }, ProfileResponse>;
+    readonly profileCancelEmail: import("../../client").ApiRoute<void, void>;
+    readonly profileSignins: import("../../client").ApiRoute<{
+        view?: "all" | "failed" | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<SignInRow>>;
+    readonly profileSessions: import("../../client").ApiRoute<void, SessionList>;
+    readonly profileRevokeSession: import("../../client").ApiRoute<{
+        session_id: number;
+    }, void>;
+};