@wssto2/vue-core 0.1.0 → 0.3.0

package/dist/identity/users/feature.d.ts

@@ -0,0 +1,34 @@
+import { type Feature } from "../../app";
+import type { Permission } from "../../platform";
+import type { Destination } from "../../router";
+import { type PersonSection } from "./personSections";
+export interface UsersFeatureOptions {
+    /** The users list and a person's record (`/users`), for whoever holds `iam.user:view`. Default true. */
+    people?: boolean;
+    /** "My profile" (`/profile`) and its entry in the account menu, for every signed-in person. Default true. */
+    profile?: boolean;
+    /** The permission that shows "Sign in as" on a person's record (what the server's `AllowImpersonation` was given). Default `iam.user:impersonate`; `false` leaves the button out. */
+    signInAs?: Permission | false;
+    /** Names of the application's areas in a person's Activity: the area key the audit records (`crm`) and the i18n key of its name. `all`, `identity` and `other` are the library's. An area without a key reads as "Other". */
+    activityAreas?: Readonly<Record<string, string>>;
+    /** Sections the application adds to a person's record after the feature's own (their roles); each is a child route `users.record.<path>`. */
+    sections?: readonly PersonSection[];
+    /** The destination of the backend's menu that opens the users list. Without it the application binds the list itself. */
+    destination?: Destination;
+}
+/**
+ * The screens of go-core's users and profile routes, one feature to install:
+ *
+ * - **People** (`people`): the users list (`/users`, route `users.index`) and a person's record (`users.record`, with its
+ *   sections: details, sign-in, sessions, sign-in history, changes), for whoever administers people. Every screen and action
+ *   is behind the permission go-core checks for it (`iam.user:view`, `iam.user:manage`), so an application installs it for
+ *   everyone and the server's catalogue decides who sees what.
+ * - **My profile** (`profile`): the signed-in person's own name and phone, password, e-mail address (changed with a code),
+ *   sessions and sign-ins (`/profile`, route `profile`), with an entry in the account menu.
+ *
+ * An application leaves out what it does not want (`people: false`) and links to the rest by route name (`usersRoutes`,
+ * `profileRoutes`). It needs `identityFeature()` next to it for "Sign in as".
+ *
+ *   createApplication({ platform, shell: backofficeShell(), features: [identityFeature(), usersFeature({ destination: "users" })] })
+ */
+export declare function usersFeature(options?: UsersFeatureOptions): Feature;

package/dist/identity/users/languages.d.ts

@@ -0,0 +1,4 @@
+import { type ComputedRef } from "vue";
+import type { SelectOption } from "../../form";
+/** The languages the application offers, as the options of a select (each named in itself). */
+export declare function useLanguages(): ComputedRef<readonly SelectOption<string>[]>;

package/dist/identity/users/list.d.ts

@@ -0,0 +1,8 @@
+import type { HttpClient } from "../../client";
+/** The views of the list, as go-core's `GET /v1/iam/users` knows them. */
+export declare const USER_VIEWS: readonly ["active", "locked", "inactive", "all"];
+/**
+ * The list of people, one definition for the list page and for the previous / next of a person's record, so both ask
+ * the server the same question. The sorts and views are the ones go-core accepts.
+ */
+export declare function userList(http: HttpClient): import("../../collection").CollectionDefinition<import("..").UserRow, "name" | "email" | "login" | "created_at", never, "inactive" | "all" | "locked" | "active">;

package/dist/identity/users/person.d.ts

@@ -0,0 +1,26 @@
+import type { InjectionKey } from "vue";
+import type { RouteResource } from "../../resource";
+import type { Load } from "../../state";
+import type { SessionList, UserDetail } from "../../modules/identity/entities";
+/** The person a record page is about, shared with its routed sections (`useRouteResourceContext(PERSON)`). */
+export declare const PERSON: InjectionKey<RouteResource<UserDetail>>;
+/** What the viewer may do with this person right now, and the dialogs that do it (they live on the record page). */
+export interface PersonActions {
+    readonly can: {
+        /** Edit the details, set a password, unlock, end sessions: whoever holds `iam.user:manage`. */
+        readonly manage: boolean;
+        /** Never one's own account (go-core refuses it), never one that is already inactive. */
+        readonly deactivate: boolean;
+        readonly activate: boolean;
+        /** Sessions of somebody else; one's own are ended in "my profile", where this device is kept. */
+        readonly endSessions: boolean;
+    };
+    deactivate(): void;
+    activate(): void;
+    setPassword(): void;
+    /** After something changed the person's state under the page (a new password unlocks, a deactivation ends sessions). */
+    refresh(): Promise<void>;
+}
+export declare const personActionsKey: InjectionKey<PersonActions>, usePersonActions: () => PersonActions;
+/** The person's live sessions: loaded once by the record page (it counts them) and shared with the Sessions section. */
+export declare const personSessionsKey: InjectionKey<Load<SessionList>>, usePersonSessions: () => Load<SessionList>;

package/dist/identity/users/personSections.d.ts

@@ -0,0 +1,22 @@
+import { type Component } from "vue";
+import type { RouteRecordRaw } from "vue-router";
+import type { UserDetail } from "../../modules/identity/entities";
+import type { AccessRequirement, RouteSection } from "../../router";
+/**
+ * A section the application adds to a person's record (their roles, say), listed after the feature's own. The component
+ * gets what `props` makes of the loaded person; `meta` is the section's route meta (its label, icon and `access`).
+ *
+ *   usersFeature({ sections: [{ path: "roles", component: PersonAccess, props: (p) => ({ subject: { kind: "user", id: p.id }, name: p.name }), meta: personRolesSection }] })
+ */
+export interface PersonSection {
+    /** The child route's path under `/users/:id/` and its name suffix (`users.record.<path>`): one lowercase word. */
+    readonly path: string;
+    readonly component: Component;
+    readonly props?: (person: UserDetail) => Record<string, unknown>;
+    readonly meta: {
+        readonly access?: AccessRequirement;
+        readonly section: RouteSection;
+    };
+}
+/** The child route of the record for an extra section. */
+export declare function personSectionRoute(section: PersonSection): RouteRecordRaw;

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

@@ -0,0 +1,22 @@
+import type { RouteRecordRaw } from "vue-router";
+/**
+ * The routes of `usersFeature`: typed targets for links (`usersRoutes.index`, `usersRoutes.record({ id })`), and the
+ * records the feature installs. The names and paths are fixed, so a link or a menu binding of the application can name
+ * them. The sections of a person's record are its children, reached by name (`users.record.sessions`).
+ */
+export interface UsersRoutes {
+    /** The records `usersFeature` installs. */
+    readonly records: readonly RouteRecordRaw[];
+    readonly index: {
+        readonly name: "users.index";
+    };
+    readonly record: (params: {
+        id: string | number;
+    }) => {
+        readonly name: "users.record";
+        readonly params: {
+            id: string | number;
+        };
+    };
+}
+export declare const usersRoutes: UsersRoutes;

package/dist/identity/users/sections/Activity.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/users/sections/Changes.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/users/sections/General.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/users/sections/Sessions.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/users/sections/SignIn.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/users/sections/SignIns.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/identity/users/status.d.ts

@@ -0,0 +1,4 @@
+import type { Status } from "../../modules/identity/entities";
+import type { Tone } from "../../state";
+/** The tone of a person's status: active is fine, locked needs attention, inactive is quiet. */
+export declare const statusTone: (status: Status) => Tone;