@abpjs/identity 0.7.6

package/dist/index.mjs

@@ -0,0 +1,1146 @@
+// src/services/identity.service.ts
+var IdentityService = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  // ========================
+  // Role Operations
+  // ========================
+  /**
+   * Get all roles
+   * @returns Promise with paginated role response
+   */
+  getRoles() {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/identity/roles"
+    });
+  }
+  /**
+   * Get a role by ID
+   * @param id - The role ID
+   * @returns Promise with the role item
+   */
+  getRoleById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/roles/${id}`
+    });
+  }
+  /**
+   * Delete a role
+   * @param id - The role ID to delete
+   * @returns Promise with the deleted role
+   */
+  deleteRole(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/identity/roles/${id}`
+    });
+  }
+  /**
+   * Create a new role
+   * @param body - The role data to create
+   * @returns Promise with the created role
+   */
+  createRole(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/identity/roles",
+      body
+    });
+  }
+  /**
+   * Update an existing role
+   * @param id - The role ID to update
+   * @param body - The updated role data
+   * @returns Promise with the updated role
+   */
+  updateRole(id, body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/identity/roles/${id}`,
+      body
+    });
+  }
+  // ========================
+  // User Operations
+  // ========================
+  /**
+   * Get users with pagination and filtering
+   * @param params - Query parameters for pagination and filtering
+   * @returns Promise with paginated user response
+   */
+  getUsers(params = {}) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/identity/users",
+      params
+    });
+  }
+  /**
+   * Get a user by ID
+   * @param id - The user ID
+   * @returns Promise with the user item
+   */
+  getUserById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/users/${id}`
+    });
+  }
+  /**
+   * Get roles assigned to a user
+   * @param id - The user ID
+   * @returns Promise with the user's roles
+   */
+  getUserRoles(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/users/${id}/roles`
+    });
+  }
+  /**
+   * Delete a user
+   * @param id - The user ID to delete
+   * @returns Promise resolving when complete
+   */
+  deleteUser(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/identity/users/${id}`
+    });
+  }
+  /**
+   * Create a new user
+   * @param body - The user data to create
+   * @returns Promise with the created user
+   */
+  createUser(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/identity/users",
+      body
+    });
+  }
+  /**
+   * Update an existing user
+   * @param id - The user ID to update
+   * @param body - The updated user data
+   * @returns Promise with the updated user
+   */
+  updateUser(id, body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}`,
+      body
+    });
+  }
+};
+
+// src/hooks/useRoles.ts
+import { useState, useCallback, useMemo } from "react";
+import { useRestService } from "@abpjs/core";
+function useRoles() {
+  const restService = useRestService();
+  const service = useMemo(() => new IdentityService(restService), [restService]);
+  const [roles, setRoles] = useState([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [selectedRole, setSelectedRole] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchRoles = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getRoles();
+      setRoles(response.items || []);
+      setTotalCount(response.totalCount || 0);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch roles";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const getRoleById = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const role = await service.getRoleById(id);
+        setSelectedRole(role);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createRole = useCallback(
+    async (role) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.createRole(role);
+        await fetchRoles();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchRoles]
+  );
+  const updateRole = useCallback(
+    async (id, role) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateRole(id, role);
+        await fetchRoles();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchRoles]
+  );
+  const deleteRole = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteRole(id);
+        await fetchRoles();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchRoles]
+  );
+  const reset = useCallback(() => {
+    setRoles([]);
+    setTotalCount(0);
+    setSelectedRole(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    roles,
+    totalCount,
+    selectedRole,
+    isLoading,
+    error,
+    fetchRoles,
+    getRoleById,
+    createRole,
+    updateRole,
+    deleteRole,
+    setSelectedRole,
+    reset
+  };
+}
+
+// src/hooks/useUsers.ts
+import { useState as useState2, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useRestService as useRestService2 } from "@abpjs/core";
+var DEFAULT_PAGE_QUERY = {
+  sorting: "userName",
+  skipCount: 0,
+  maxResultCount: 10
+};
+function useUsers() {
+  const restService = useRestService2();
+  const service = useMemo2(() => new IdentityService(restService), [restService]);
+  const [users, setUsers] = useState2([]);
+  const [totalCount, setTotalCount] = useState2(0);
+  const [selectedUser, setSelectedUser] = useState2(null);
+  const [selectedUserRoles, setSelectedUserRoles] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [pageQuery, setPageQuery] = useState2(DEFAULT_PAGE_QUERY);
+  const fetchUsers = useCallback2(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      const queryParams = params || pageQuery;
+      try {
+        const response = await service.getUsers(queryParams);
+        setUsers(response.items || []);
+        setTotalCount(response.totalCount || 0);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch users";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, pageQuery]
+  );
+  const getUserById = useCallback2(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const user = await service.getUserById(id);
+        setSelectedUser(user);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const getUserRoles = useCallback2(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await service.getUserRoles(id);
+        setSelectedUserRoles(response.items || []);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch user roles";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createUser = useCallback2(
+    async (user) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.createUser(user);
+        await fetchUsers();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchUsers]
+  );
+  const updateUser = useCallback2(
+    async (id, user) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateUser(id, user);
+        await fetchUsers();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchUsers]
+  );
+  const deleteUser = useCallback2(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteUser(id);
+        await fetchUsers();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchUsers]
+  );
+  const reset = useCallback2(() => {
+    setUsers([]);
+    setTotalCount(0);
+    setSelectedUser(null);
+    setSelectedUserRoles([]);
+    setIsLoading(false);
+    setError(null);
+    setPageQuery(DEFAULT_PAGE_QUERY);
+  }, []);
+  return {
+    users,
+    totalCount,
+    selectedUser,
+    selectedUserRoles,
+    isLoading,
+    error,
+    pageQuery,
+    fetchUsers,
+    getUserById,
+    getUserRoles,
+    createUser,
+    updateUser,
+    deleteUser,
+    setSelectedUser,
+    setPageQuery,
+    reset
+  };
+}
+
+// src/hooks/useIdentity.ts
+import { useCallback as useCallback3, useMemo as useMemo3 } from "react";
+function useIdentity() {
+  const rolesHook = useRoles();
+  const usersHook = useUsers();
+  const isLoading = useMemo3(
+    () => rolesHook.isLoading || usersHook.isLoading,
+    [rolesHook.isLoading, usersHook.isLoading]
+  );
+  const error = useMemo3(
+    () => rolesHook.error || usersHook.error,
+    [rolesHook.error, usersHook.error]
+  );
+  const resetAll = useCallback3(() => {
+    rolesHook.reset();
+    usersHook.reset();
+  }, [rolesHook, usersHook]);
+  return {
+    roles: rolesHook,
+    users: usersHook,
+    isLoading,
+    error,
+    resetAll
+  };
+}
+
+// src/components/Roles/RolesComponent.tsx
+import { useEffect, useState as useState3, useCallback as useCallback4 } from "react";
+import { useLocalization } from "@abpjs/core";
+import { Modal, useConfirmation, Toaster, Alert, Button, Checkbox, FormField } from "@abpjs/theme-shared";
+import { PermissionManagementModal } from "@abpjs/permission-management";
+import {
+  Box,
+  Flex,
+  Input,
+  Table,
+  Spinner,
+  VStack,
+  Menu,
+  Text
+} from "@chakra-ui/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_FORM_STATE = {
+  name: "",
+  isDefault: false,
+  isPublic: false
+};
+function RolesComponent({
+  onRoleCreated,
+  onRoleUpdated,
+  onRoleDeleted
+}) {
+  const { t } = useLocalization();
+  const confirmation = useConfirmation();
+  const {
+    roles,
+    selectedRole,
+    isLoading,
+    error,
+    fetchRoles,
+    getRoleById,
+    createRole,
+    updateRole,
+    deleteRole,
+    setSelectedRole
+  } = useRoles();
+  const [isModalOpen, setIsModalOpen] = useState3(false);
+  const [formState, setFormState] = useState3(DEFAULT_FORM_STATE);
+  const [isSubmitting, setIsSubmitting] = useState3(false);
+  const [isPermissionModalOpen, setIsPermissionModalOpen] = useState3(false);
+  const [permissionProviderKey, setPermissionProviderKey] = useState3("");
+  const [searchTerm, setSearchTerm] = useState3("");
+  useEffect(() => {
+    fetchRoles();
+  }, [fetchRoles]);
+  const filteredRoles = roles.filter(
+    (role) => !searchTerm || role.name.toLowerCase().includes(searchTerm.toLowerCase())
+  );
+  const handleAdd = useCallback4(() => {
+    setSelectedRole(null);
+    setFormState(DEFAULT_FORM_STATE);
+    setIsModalOpen(true);
+  }, [setSelectedRole]);
+  const handleEdit = useCallback4(
+    async (id) => {
+      const result = await getRoleById(id);
+      if (result.success && selectedRole) {
+        setFormState({
+          name: selectedRole.name || "",
+          isDefault: selectedRole.isDefault || false,
+          isPublic: selectedRole.isPublic || false
+        });
+        setIsModalOpen(true);
+      }
+    },
+    [getRoleById, selectedRole]
+  );
+  useEffect(() => {
+    if (selectedRole) {
+      setFormState({
+        name: selectedRole.name || "",
+        isDefault: selectedRole.isDefault || false,
+        isPublic: selectedRole.isPublic || false
+      });
+    }
+  }, [selectedRole]);
+  const handleDelete = useCallback4(
+    async (id, name) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::RoleDeletionConfirmationMessage", name),
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === Toaster.Status.confirm) {
+        const result = await deleteRole(id);
+        if (result.success) {
+          onRoleDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteRole, onRoleDeleted]
+  );
+  const handleOpenPermissions = useCallback4((roleName) => {
+    setPermissionProviderKey(roleName);
+    setIsPermissionModalOpen(true);
+  }, []);
+  const handleSubmit = useCallback4(async () => {
+    if (!formState.name.trim()) return;
+    setIsSubmitting(true);
+    const roleData = {
+      name: formState.name.trim(),
+      isDefault: formState.isDefault,
+      isPublic: formState.isPublic
+    };
+    let result;
+    if (selectedRole?.id) {
+      result = await updateRole(selectedRole.id, roleData);
+      if (result.success) {
+        onRoleUpdated?.({ ...selectedRole, ...roleData });
+      }
+    } else {
+      result = await createRole(roleData);
+      if (result.success) {
+        onRoleCreated?.({ ...roleData, id: "", isStatic: false, concurrencyStamp: "" });
+      }
+    }
+    setIsSubmitting(false);
+    if (result.success) {
+      setIsModalOpen(false);
+      setFormState(DEFAULT_FORM_STATE);
+      setSelectedRole(null);
+    }
+  }, [formState, selectedRole, updateRole, createRole, onRoleCreated, onRoleUpdated, setSelectedRole]);
+  const handleModalClose = useCallback4(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE);
+    setSelectedRole(null);
+  }, [setSelectedRole]);
+  const handleInputChange = useCallback4(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs(Box, { id: "identity-roles-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx(Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::Roles") }),
+      /* @__PURE__ */ jsx(Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewRole") })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { mb: 4, children: /* @__PURE__ */ jsx(
+      Input,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ jsx(Alert, { status: "error", mb: 4, children: error }),
+    isLoading && roles.length === 0 && /* @__PURE__ */ jsx(Flex, { justify: "center", py: 8, children: /* @__PURE__ */ jsx(Spinner, { size: "lg" }) }),
+    roles.length > 0 && /* @__PURE__ */ jsxs(Table.Root, { variant: "outline", children: [
+      /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpIdentity::RoleName") })
+      ] }) }),
+      /* @__PURE__ */ jsx(Table.Body, { children: filteredRoles.map((role) => /* @__PURE__ */ jsxs(Table.Row, { children: [
+        /* @__PURE__ */ jsx(Table.Cell, { children: /* @__PURE__ */ jsxs(Menu.Root, { children: [
+          /* @__PURE__ */ jsx(Menu.Trigger, { asChild: true, children: /* @__PURE__ */ jsx(Button, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+          /* @__PURE__ */ jsx(Menu.Positioner, { children: /* @__PURE__ */ jsxs(Menu.Content, { children: [
+            /* @__PURE__ */ jsx(Menu.Item, { value: "edit", onClick: () => handleEdit(role.id), children: t("AbpIdentity::Edit") }),
+            /* @__PURE__ */ jsx(Menu.Item, { value: "permissions", onClick: () => handleOpenPermissions(role.name), children: t("AbpIdentity::Permissions") }),
+            !role.isStatic && /* @__PURE__ */ jsx(
+              Menu.Item,
+              {
+                value: "delete",
+                color: "red.500",
+                onClick: () => handleDelete(role.id, role.name),
+                children: t("AbpIdentity::Delete")
+              }
+            )
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: role.name })
+      ] }, role.id)) })
+    ] }),
+    !isLoading && roles.length === 0 && /* @__PURE__ */ jsx(Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoRolesFound") }),
+    /* @__PURE__ */ jsx(
+      Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: selectedRole?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewRole"),
+        footer: /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.name.trim(),
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+          /* @__PURE__ */ jsx(FormField, { label: t("AbpIdentity::RoleName"), required: true, children: /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: formState.name,
+              onChange: (e) => handleInputChange("name", e.target.value),
+              maxLength: 256,
+              placeholder: t("AbpIdentity::RoleName")
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              checked: formState.isDefault,
+              onChange: (e) => handleInputChange("isDefault", e.target.checked),
+              children: t("AbpIdentity::DisplayName:IsDefault")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              checked: formState.isPublic,
+              onChange: (e) => handleInputChange("isPublic", e.target.checked),
+              children: t("AbpIdentity::DisplayName:IsPublic")
+            }
+          )
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      PermissionManagementModal,
+      {
+        visible: isPermissionModalOpen,
+        onVisibleChange: setIsPermissionModalOpen,
+        providerName: "R",
+        providerKey: permissionProviderKey
+      }
+    )
+  ] });
+}
+
+// src/components/Users/UsersComponent.tsx
+import { useEffect as useEffect2, useState as useState4, useCallback as useCallback5, useMemo as useMemo4 } from "react";
+import { useLocalization as useLocalization2 } from "@abpjs/core";
+import { Modal as Modal2, useConfirmation as useConfirmation2, Toaster as Toaster2, Alert as Alert2, Button as Button2, Checkbox as Checkbox2, FormField as FormField2 } from "@abpjs/theme-shared";
+import { PermissionManagementModal as PermissionManagementModal2 } from "@abpjs/permission-management";
+import {
+  Box as Box2,
+  Flex as Flex2,
+  Input as Input2,
+  Table as Table2,
+  Spinner as Spinner2,
+  VStack as VStack2,
+  Menu as Menu2,
+  Text as Text2,
+  Tabs,
+  SimpleGrid
+} from "@chakra-ui/react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var DEFAULT_FORM_STATE2 = {
+  userName: "",
+  name: "",
+  surname: "",
+  email: "",
+  phoneNumber: "",
+  password: "",
+  lockoutEnabled: true,
+  twoFactorEnabled: true,
+  roleNames: []
+};
+function UsersComponent({
+  onUserCreated,
+  onUserUpdated,
+  onUserDeleted
+}) {
+  const { t } = useLocalization2();
+  const confirmation = useConfirmation2();
+  const {
+    users,
+    totalCount,
+    selectedUser,
+    selectedUserRoles,
+    isLoading,
+    error,
+    pageQuery,
+    fetchUsers,
+    getUserById,
+    getUserRoles,
+    createUser,
+    updateUser,
+    deleteUser,
+    setSelectedUser,
+    setPageQuery
+  } = useUsers();
+  const { roles, fetchRoles } = useRoles();
+  const [isModalOpen, setIsModalOpen] = useState4(false);
+  const [formState, setFormState] = useState4(DEFAULT_FORM_STATE2);
+  const [isSubmitting, setIsSubmitting] = useState4(false);
+  const [isPermissionModalOpen, setIsPermissionModalOpen] = useState4(false);
+  const [permissionProviderKey, setPermissionProviderKey] = useState4("");
+  const [searchTerm, setSearchTerm] = useState4("");
+  const [debouncedSearchTerm, setDebouncedSearchTerm] = useState4("");
+  useEffect2(() => {
+    fetchRoles();
+    fetchUsers();
+  }, [fetchRoles, fetchUsers]);
+  useEffect2(() => {
+    const timer = setTimeout(() => {
+      setDebouncedSearchTerm(searchTerm);
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [searchTerm]);
+  useEffect2(() => {
+    const newQuery = {
+      ...pageQuery,
+      filter: debouncedSearchTerm || void 0,
+      skipCount: 0
+    };
+    setPageQuery(newQuery);
+    fetchUsers(newQuery);
+  }, [debouncedSearchTerm]);
+  const selectedRoleNames = useMemo4(() => {
+    return selectedUserRoles.map((role) => role.name);
+  }, [selectedUserRoles]);
+  const handleAdd = useCallback5(() => {
+    setSelectedUser(null);
+    setFormState(DEFAULT_FORM_STATE2);
+    setIsModalOpen(true);
+  }, [setSelectedUser]);
+  const handleEdit = useCallback5(
+    async (id) => {
+      await Promise.all([getUserById(id), getUserRoles(id)]);
+      setIsModalOpen(true);
+    },
+    [getUserById, getUserRoles]
+  );
+  useEffect2(() => {
+    if (selectedUser) {
+      setFormState({
+        userName: selectedUser.userName || "",
+        name: selectedUser.name || "",
+        surname: selectedUser.surname || "",
+        email: selectedUser.email || "",
+        phoneNumber: selectedUser.phoneNumber || "",
+        password: "",
+        lockoutEnabled: selectedUser.lockoutEnabled ?? true,
+        twoFactorEnabled: selectedUser.twoFactorEnabled ?? true,
+        roleNames: selectedRoleNames
+      });
+    }
+  }, [selectedUser, selectedRoleNames]);
+  const handleDelete = useCallback5(
+    async (id, userName) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::UserDeletionConfirmationMessage", userName),
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === Toaster2.Status.confirm) {
+        const result = await deleteUser(id);
+        if (result.success) {
+          onUserDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteUser, onUserDeleted]
+  );
+  const handleOpenPermissions = useCallback5((userId) => {
+    setPermissionProviderKey(userId);
+    setIsPermissionModalOpen(true);
+  }, []);
+  const handleSubmit = useCallback5(async () => {
+    if (!formState.userName.trim() || !formState.email.trim()) return;
+    if (!selectedUser?.id && !formState.password) return;
+    setIsSubmitting(true);
+    const userData = {
+      userName: formState.userName.trim(),
+      name: formState.name.trim(),
+      surname: formState.surname.trim(),
+      email: formState.email.trim(),
+      phoneNumber: formState.phoneNumber.trim(),
+      password: formState.password,
+      lockoutEnabled: formState.lockoutEnabled,
+      twoFactorEnabled: formState.twoFactorEnabled,
+      roleNames: formState.roleNames
+    };
+    let result;
+    if (selectedUser?.id) {
+      result = await updateUser(selectedUser.id, userData);
+      if (result.success) {
+        onUserUpdated?.({
+          ...selectedUser,
+          ...userData
+        });
+      }
+    } else {
+      result = await createUser(userData);
+      if (result.success) {
+        onUserCreated?.({
+          ...userData,
+          id: "",
+          tenantId: "",
+          emailConfirmed: false,
+          phoneNumberConfirmed: false,
+          isLockedOut: false,
+          concurrencyStamp: ""
+        });
+      }
+    }
+    setIsSubmitting(false);
+    if (result.success) {
+      setIsModalOpen(false);
+      setFormState(DEFAULT_FORM_STATE2);
+      setSelectedUser(null);
+    }
+  }, [formState, selectedUser, updateUser, createUser, onUserCreated, onUserUpdated, setSelectedUser]);
+  const handleModalClose = useCallback5(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE2);
+    setSelectedUser(null);
+  }, [setSelectedUser]);
+  const handleInputChange = useCallback5(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handleRoleChange = useCallback5((roleName, checked) => {
+    setFormState((prev) => ({
+      ...prev,
+      roleNames: checked ? [...prev.roleNames, roleName] : prev.roleNames.filter((name) => name !== roleName)
+    }));
+  }, []);
+  const handlePageChange = useCallback5(
+    (newSkipCount) => {
+      const newQuery = { ...pageQuery, skipCount: newSkipCount };
+      setPageQuery(newQuery);
+      fetchUsers(newQuery);
+    },
+    [pageQuery, setPageQuery, fetchUsers]
+  );
+  return /* @__PURE__ */ jsxs2(Box2, { id: "identity-users-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ jsxs2(Flex2, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx2(Text2, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::Users") }),
+      /* @__PURE__ */ jsx2(Button2, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewUser") })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { mb: 4, children: /* @__PURE__ */ jsx2(
+      Input2,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ jsx2(Alert2, { status: "error", mb: 4, children: error }),
+    isLoading && users.length === 0 && /* @__PURE__ */ jsx2(Flex2, { justify: "center", py: 8, children: /* @__PURE__ */ jsx2(Spinner2, { size: "lg" }) }),
+    users.length > 0 && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsxs2(Table2.Root, { variant: "outline", children: [
+        /* @__PURE__ */ jsx2(Table2.Header, { children: /* @__PURE__ */ jsxs2(Table2.Row, { children: [
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::UserName") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::EmailAddress") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::PhoneNumber") })
+        ] }) }),
+        /* @__PURE__ */ jsx2(Table2.Body, { children: users.map((user) => /* @__PURE__ */ jsxs2(Table2.Row, { children: [
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsxs2(Menu2.Root, { children: [
+            /* @__PURE__ */ jsx2(Menu2.Trigger, { asChild: true, children: /* @__PURE__ */ jsx2(Button2, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+            /* @__PURE__ */ jsx2(Menu2.Positioner, { children: /* @__PURE__ */ jsxs2(Menu2.Content, { children: [
+              /* @__PURE__ */ jsx2(Menu2.Item, { value: "edit", onClick: () => handleEdit(user.id), children: t("AbpIdentity::Edit") }),
+              /* @__PURE__ */ jsx2(Menu2.Item, { value: "permissions", onClick: () => handleOpenPermissions(user.id), children: t("AbpIdentity::Permissions") }),
+              /* @__PURE__ */ jsx2(
+                Menu2.Item,
+                {
+                  value: "delete",
+                  color: "red.500",
+                  onClick: () => handleDelete(user.id, user.userName),
+                  children: t("AbpIdentity::Delete")
+                }
+              )
+            ] }) })
+          ] }) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: user.userName }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: user.email }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: user.phoneNumber })
+        ] }, user.id)) })
+      ] }),
+      /* @__PURE__ */ jsxs2(Flex2, { justify: "space-between", align: "center", mt: 4, children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "gray.600", children: [
+          t("AbpIdentity::TotalCount"),
+          ": ",
+          totalCount
+        ] }),
+        /* @__PURE__ */ jsxs2(Flex2, { gap: 2, children: [
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              disabled: (pageQuery.skipCount || 0) === 0,
+              onClick: () => handlePageChange(
+                Math.max(0, (pageQuery.skipCount || 0) - (pageQuery.maxResultCount || 10))
+              ),
+              children: t("AbpIdentity::Previous")
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              disabled: (pageQuery.skipCount || 0) + (pageQuery.maxResultCount || 10) >= totalCount,
+              onClick: () => handlePageChange((pageQuery.skipCount || 0) + (pageQuery.maxResultCount || 10)),
+              children: t("AbpIdentity::Next")
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    !isLoading && users.length === 0 && /* @__PURE__ */ jsx2(Text2, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoUsersFound") }),
+    /* @__PURE__ */ jsx2(
+      Modal2,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        size: "lg",
+        header: selectedUser?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewUser"),
+        footer: /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx2(Button2, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.userName.trim() || !formState.email.trim() || !selectedUser?.id && !formState.password,
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ jsxs2(Tabs.Root, { defaultValue: "info", children: [
+          /* @__PURE__ */ jsxs2(Tabs.List, { children: [
+            /* @__PURE__ */ jsx2(Tabs.Trigger, { value: "info", children: t("AbpIdentity::UserInformations") }),
+            /* @__PURE__ */ jsx2(Tabs.Trigger, { value: "roles", children: t("AbpIdentity::Roles") })
+          ] }),
+          /* @__PURE__ */ jsx2(Tabs.Content, { value: "info", children: /* @__PURE__ */ jsxs2(VStack2, { gap: 4, align: "stretch", pt: 4, children: [
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::UserName"), required: true, children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                value: formState.userName,
+                onChange: (e) => handleInputChange("userName", e.target.value),
+                maxLength: 256
+              }
+            ) }),
+            /* @__PURE__ */ jsxs2(SimpleGrid, { columns: 2, gap: 4, children: [
+              /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::Name"), children: /* @__PURE__ */ jsx2(
+                Input2,
+                {
+                  value: formState.name,
+                  onChange: (e) => handleInputChange("name", e.target.value),
+                  maxLength: 64
+                }
+              ) }),
+              /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::DisplayName:Surname"), children: /* @__PURE__ */ jsx2(
+                Input2,
+                {
+                  value: formState.surname,
+                  onChange: (e) => handleInputChange("surname", e.target.value),
+                  maxLength: 64
+                }
+              ) })
+            ] }),
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::Password"), required: !selectedUser?.id, children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                type: "password",
+                value: formState.password,
+                onChange: (e) => handleInputChange("password", e.target.value),
+                autoComplete: "new-password",
+                maxLength: 32,
+                placeholder: selectedUser?.id ? t("AbpIdentity::LeaveBlankToKeepCurrent") : ""
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::EmailAddress"), required: true, children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                type: "email",
+                value: formState.email,
+                onChange: (e) => handleInputChange("email", e.target.value),
+                maxLength: 256
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::PhoneNumber"), children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                value: formState.phoneNumber,
+                onChange: (e) => handleInputChange("phoneNumber", e.target.value),
+                maxLength: 16
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(
+              Checkbox2,
+              {
+                checked: formState.lockoutEnabled,
+                onChange: (e) => handleInputChange("lockoutEnabled", e.target.checked),
+                children: t("AbpIdentity::DisplayName:LockoutEnabled")
+              }
+            ),
+            /* @__PURE__ */ jsx2(
+              Checkbox2,
+              {
+                checked: formState.twoFactorEnabled,
+                onChange: (e) => handleInputChange("twoFactorEnabled", e.target.checked),
+                children: t("AbpIdentity::DisplayName:TwoFactorEnabled")
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx2(Tabs.Content, { value: "roles", children: /* @__PURE__ */ jsxs2(VStack2, { gap: 2, align: "stretch", pt: 4, children: [
+            roles.map((role) => /* @__PURE__ */ jsx2(
+              Checkbox2,
+              {
+                checked: formState.roleNames.includes(role.name),
+                onChange: (e) => handleRoleChange(role.name, e.target.checked),
+                children: role.name
+              },
+              role.id
+            )),
+            roles.length === 0 && /* @__PURE__ */ jsx2(Text2, { color: "gray.500", children: t("AbpIdentity::NoRolesFound") })
+          ] }) })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      PermissionManagementModal2,
+      {
+        visible: isPermissionModalOpen,
+        onVisibleChange: setIsPermissionModalOpen,
+        providerName: "U",
+        providerKey: permissionProviderKey
+      }
+    )
+  ] });
+}
+
+// src/constants/routes.ts
+import { eLayoutType } from "@abpjs/core";
+var IDENTITY_ROUTES = [
+  {
+    name: "AbpUiNavigation::Menu:Administration",
+    path: "",
+    order: 1,
+    wrapper: true
+  },
+  {
+    name: "AbpIdentity::Menu:IdentityManagement",
+    path: "identity",
+    order: 1,
+    parentName: "AbpUiNavigation::Menu:Administration",
+    layout: eLayoutType.application,
+    children: [
+      {
+        path: "roles",
+        name: "AbpIdentity::Roles",
+        order: 2,
+        requiredPolicy: "AbpIdentity.Roles"
+      },
+      {
+        path: "users",
+        name: "AbpIdentity::Users",
+        order: 1,
+        requiredPolicy: "AbpIdentity.Users"
+      }
+    ]
+  }
+];
+var IDENTITY_ROUTE_PATHS = {
+  /** Base path for identity module */
+  BASE: "/identity",
+  /** Roles management path */
+  ROLES: "/identity/roles",
+  /** Users management path */
+  USERS: "/identity/users"
+};
+var IDENTITY_POLICIES = {
+  /** Policy for roles management */
+  ROLES: "AbpIdentity.Roles",
+  /** Policy for users management */
+  USERS: "AbpIdentity.Users",
+  /** Policy for creating users */
+  USERS_CREATE: "AbpIdentity.Users.Create",
+  /** Policy for updating users */
+  USERS_UPDATE: "AbpIdentity.Users.Update",
+  /** Policy for deleting users */
+  USERS_DELETE: "AbpIdentity.Users.Delete",
+  /** Policy for creating roles */
+  ROLES_CREATE: "AbpIdentity.Roles.Create",
+  /** Policy for updating roles */
+  ROLES_UPDATE: "AbpIdentity.Roles.Update",
+  /** Policy for deleting roles */
+  ROLES_DELETE: "AbpIdentity.Roles.Delete"
+};
+export {
+  IDENTITY_POLICIES,
+  IDENTITY_ROUTES,
+  IDENTITY_ROUTE_PATHS,
+  IdentityService,
+  RolesComponent,
+  UsersComponent,
+  useIdentity,
+  useRoles,
+  useUsers
+};