@abpjs/language-management 0.7.2

package/dist/index.mjs

@@ -0,0 +1,1175 @@
+// src/constants/routes.ts
+var LANGUAGE_MANAGEMENT_ROUTES = {
+  routes: [
+    {
+      name: "Languages",
+      path: "language-management",
+      layout: "application",
+      order: 101,
+      children: [
+        {
+          name: "Languages",
+          path: "languages",
+          order: 1
+        },
+        {
+          name: "Language Texts",
+          path: "texts",
+          order: 2
+        }
+      ]
+    }
+  ]
+};
+
+// src/services/language-management.service.ts
+var LanguageManagementService = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  // ========================
+  // Language Operations
+  // ========================
+  /**
+   * Get all languages with optional pagination
+   * @param params - Optional query parameters for pagination and filtering
+   * @returns Promise with paginated language response
+   */
+  getLanguages(params = {}) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/language-management/languages",
+      params
+    });
+  }
+  /**
+   * Get a language by ID
+   * @param id - The language ID
+   * @returns Promise with the language
+   */
+  getLanguageById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/language-management/languages/${id}`
+    });
+  }
+  /**
+   * Create a new language
+   * @param body - The language data to create
+   * @returns Promise with the created language
+   */
+  createLanguage(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/language-management/languages",
+      body
+    });
+  }
+  /**
+   * Update an existing language
+   * @param id - The language ID to update
+   * @param body - The updated language data
+   * @returns Promise with the updated language
+   */
+  updateLanguage(id, body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/language-management/languages/${id}`,
+      body
+    });
+  }
+  /**
+   * Delete a language
+   * @param id - The language ID to delete
+   * @returns Promise resolving when complete
+   */
+  deleteLanguage(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/language-management/languages/${id}`
+    });
+  }
+  /**
+   * Set a language as the default language
+   * @param id - The language ID to set as default
+   * @returns Promise resolving when complete
+   */
+  setAsDefaultLanguage(id) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/language-management/languages/${id}/set-as-default`
+    });
+  }
+  // ========================
+  // Culture Operations
+  // ========================
+  /**
+   * Get all available cultures
+   * @returns Promise with list of cultures
+   */
+  getCultures() {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/language-management/languages/culture-list"
+    });
+  }
+  // ========================
+  // Resource Operations
+  // ========================
+  /**
+   * Get all available localization resources
+   * @returns Promise with list of resources
+   */
+  getResources() {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/language-management/languages/resources"
+    });
+  }
+  // ========================
+  // Language Text Operations
+  // ========================
+  /**
+   * Get language texts with pagination and filtering
+   * @param params - Query parameters including resource name, cultures, and filter options
+   * @returns Promise with paginated language text response
+   */
+  getLanguageTexts(params) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/language-management/language-texts",
+      params
+    });
+  }
+  /**
+   * Get a language text by name
+   * @param params - Parameters identifying the language text
+   * @returns Promise with the language text
+   */
+  getLanguageTextByName(params) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/language-management/language-texts",
+      params
+    });
+  }
+  /**
+   * Update a language text by name
+   * @param params - Parameters including the new value
+   * @returns Promise with the updated language text
+   */
+  updateLanguageTextByName(params) {
+    const { resourceName, cultureName, name, value } = params;
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/language-management/language-texts/${resourceName}/${cultureName}/${name}`,
+      body: { value }
+    });
+  }
+  /**
+   * Restore a language text to its default value
+   * @param params - Parameters identifying the language text
+   * @returns Promise resolving when complete
+   */
+  restoreLanguageTextByName(params) {
+    const { resourceName, cultureName, name } = params;
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/language-management/language-texts/${resourceName}/${cultureName}/${name}/restore`
+    });
+  }
+};
+
+// src/hooks/useLanguages.ts
+import { useState, useCallback, useMemo } from "react";
+import { useRestService } from "@abpjs/core";
+function useLanguages() {
+  const restService = useRestService();
+  const service = useMemo(() => new LanguageManagementService(restService), [restService]);
+  const [languages, setLanguages] = useState([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [cultures, setCultures] = useState([]);
+  const [selectedLanguage, setSelectedLanguage] = useState(
+    null
+  );
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [sortKey, setSortKey] = useState("displayName");
+  const [sortOrder, setSortOrder] = useState("");
+  const fetchLanguages = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await service.getLanguages(params);
+        setLanguages(response.items || []);
+        setTotalCount(response.totalCount || 0);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch languages";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const fetchCultures = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getCultures();
+      setCultures(response || []);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch cultures";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const getLanguageById = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const language = await service.getLanguageById(id);
+        setSelectedLanguage(language);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch language";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createLanguage = useCallback(
+    async (language) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.createLanguage(language);
+        await fetchLanguages();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create language";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchLanguages]
+  );
+  const updateLanguage = useCallback(
+    async (id, language) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateLanguage(id, language);
+        await fetchLanguages();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update language";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchLanguages]
+  );
+  const deleteLanguage = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteLanguage(id);
+        await fetchLanguages();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete language";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchLanguages]
+  );
+  const setAsDefaultLanguage = useCallback(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.setAsDefaultLanguage(id);
+        await fetchLanguages();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to set language as default";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchLanguages]
+  );
+  const reset = useCallback(() => {
+    setLanguages([]);
+    setTotalCount(0);
+    setCultures([]);
+    setSelectedLanguage(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    languages,
+    totalCount,
+    cultures,
+    selectedLanguage,
+    isLoading,
+    error,
+    sortKey,
+    sortOrder,
+    fetchLanguages,
+    fetchCultures,
+    getLanguageById,
+    createLanguage,
+    updateLanguage,
+    deleteLanguage,
+    setAsDefaultLanguage,
+    setSelectedLanguage,
+    setSortKey,
+    setSortOrder,
+    reset
+  };
+}
+
+// src/hooks/useLanguageTexts.ts
+import { useState as useState2, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useRestService as useRestService2 } from "@abpjs/core";
+function useLanguageTexts() {
+  const restService = useRestService2();
+  const service = useMemo2(() => new LanguageManagementService(restService), [restService]);
+  const [languageTexts, setLanguageTexts] = useState2([]);
+  const [totalCount, setTotalCount] = useState2(0);
+  const [resources, setResources] = useState2([]);
+  const [selectedLanguageText, setSelectedLanguageText] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [sortKey, setSortKey] = useState2("name");
+  const [sortOrder, setSortOrder] = useState2("");
+  const [lastQueryParams, setLastQueryParams] = useState2(null);
+  const fetchLanguageTexts = useCallback2(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      setLastQueryParams(params);
+      try {
+        const response = await service.getLanguageTexts(params);
+        setLanguageTexts(response.items || []);
+        setTotalCount(response.totalCount || 0);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch language texts";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const fetchResources = useCallback2(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getResources();
+      setResources(response || []);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch resources";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const getLanguageTextByName = useCallback2(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const languageText = await service.getLanguageTextByName(params);
+        setSelectedLanguageText(languageText);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch language text";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const updateLanguageTextByName = useCallback2(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateLanguageTextByName(params);
+        if (lastQueryParams) {
+          await fetchLanguageTexts(lastQueryParams);
+        } else {
+          setIsLoading(false);
+        }
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update language text";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, lastQueryParams, fetchLanguageTexts]
+  );
+  const restoreLanguageTextByName = useCallback2(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.restoreLanguageTextByName(params);
+        if (lastQueryParams) {
+          await fetchLanguageTexts(lastQueryParams);
+        } else {
+          setIsLoading(false);
+        }
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to restore language text";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, lastQueryParams, fetchLanguageTexts]
+  );
+  const reset = useCallback2(() => {
+    setLanguageTexts([]);
+    setTotalCount(0);
+    setResources([]);
+    setSelectedLanguageText(null);
+    setIsLoading(false);
+    setError(null);
+    setLastQueryParams(null);
+  }, []);
+  return {
+    languageTexts,
+    totalCount,
+    resources,
+    selectedLanguageText,
+    isLoading,
+    error,
+    sortKey,
+    sortOrder,
+    fetchLanguageTexts,
+    fetchResources,
+    getLanguageTextByName,
+    updateLanguageTextByName,
+    restoreLanguageTextByName,
+    setSelectedLanguageText,
+    setSortKey,
+    setSortOrder,
+    reset
+  };
+}
+
+// src/components/Languages/LanguagesComponent.tsx
+import { useEffect, useState as useState3, useCallback as useCallback3 } from "react";
+import { useLocalization } from "@abpjs/core";
+import { Modal, useConfirmation, Toaster, Alert, Button, FormField } from "@abpjs/theme-shared";
+import {
+  Box,
+  Flex,
+  Input,
+  Table,
+  Spinner,
+  VStack,
+  Menu,
+  Text,
+  Badge
+} from "@chakra-ui/react";
+import { NativeSelectRoot, NativeSelectField } from "@chakra-ui/react";
+import { Checkbox } from "@chakra-ui/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_FORM_STATE = {
+  cultureName: "",
+  uiCultureName: "",
+  displayName: "",
+  flagIcon: "",
+  isEnabled: true
+};
+function LanguagesComponent({
+  onLanguageCreated,
+  onLanguageUpdated,
+  onLanguageDeleted
+}) {
+  const { t } = useLocalization();
+  const confirmation = useConfirmation();
+  const {
+    languages,
+    cultures,
+    selectedLanguage,
+    isLoading,
+    error,
+    fetchLanguages,
+    fetchCultures,
+    getLanguageById,
+    createLanguage,
+    updateLanguage,
+    deleteLanguage,
+    setAsDefaultLanguage,
+    setSelectedLanguage
+  } = useLanguages();
+  const [isModalOpen, setIsModalOpen] = useState3(false);
+  const [formState, setFormState] = useState3(DEFAULT_FORM_STATE);
+  const [isSubmitting, setIsSubmitting] = useState3(false);
+  const [isEditing, setIsEditing] = useState3(false);
+  const [searchTerm, setSearchTerm] = useState3("");
+  useEffect(() => {
+    fetchLanguages();
+    fetchCultures();
+  }, [fetchLanguages, fetchCultures]);
+  const filteredLanguages = languages.filter(
+    (lang) => !searchTerm || lang.displayName.toLowerCase().includes(searchTerm.toLowerCase()) || lang.cultureName.toLowerCase().includes(searchTerm.toLowerCase())
+  );
+  const handleAdd = useCallback3(() => {
+    setSelectedLanguage(null);
+    setFormState(DEFAULT_FORM_STATE);
+    setIsEditing(false);
+    setIsModalOpen(true);
+  }, [setSelectedLanguage]);
+  const handleEdit = useCallback3(
+    async (id) => {
+      const result = await getLanguageById(id);
+      if (result.success) {
+        setIsEditing(true);
+        setIsModalOpen(true);
+      }
+    },
+    [getLanguageById]
+  );
+  useEffect(() => {
+    if (selectedLanguage && isEditing) {
+      setFormState({
+        cultureName: selectedLanguage.cultureName || "",
+        uiCultureName: selectedLanguage.uiCultureName || "",
+        displayName: selectedLanguage.displayName || "",
+        flagIcon: selectedLanguage.flagIcon || "",
+        isEnabled: selectedLanguage.isEnabled ?? true
+      });
+    }
+  }, [selectedLanguage, isEditing]);
+  const handleDelete = useCallback3(
+    async (id, displayName) => {
+      const status = await confirmation.warn(
+        t("AbpLanguageManagement::LanguageDeletionConfirmationMessage", displayName) || `Are you sure you want to delete the language '${displayName}'?`,
+        t("AbpLanguageManagement::AreYouSure") || "Are you sure?"
+      );
+      if (status === Toaster.Status.confirm) {
+        const result = await deleteLanguage(id);
+        if (result.success) {
+          onLanguageDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteLanguage, onLanguageDeleted]
+  );
+  const handleSetAsDefault = useCallback3(
+    async (id) => {
+      const status = await confirmation.info(
+        t("AbpLanguageManagement::SetAsDefaultLanguageConfirmationMessage") || "Are you sure you want to set this language as the default?",
+        t("AbpLanguageManagement::AreYouSure") || "Are you sure?"
+      );
+      if (status === Toaster.Status.confirm) {
+        await setAsDefaultLanguage(id);
+      }
+    },
+    [confirmation, t, setAsDefaultLanguage]
+  );
+  const handleSubmit = useCallback3(async () => {
+    if (!isEditing && !formState.cultureName) return;
+    if (!formState.displayName.trim()) return;
+    setIsSubmitting(true);
+    let result;
+    if (isEditing && selectedLanguage?.id) {
+      const updateData = {
+        displayName: formState.displayName.trim(),
+        flagIcon: formState.flagIcon,
+        isEnabled: formState.isEnabled
+      };
+      result = await updateLanguage(selectedLanguage.id, updateData);
+      if (result.success) {
+        onLanguageUpdated?.({
+          ...selectedLanguage,
+          ...updateData
+        });
+      }
+    } else {
+      const createData = {
+        cultureName: formState.cultureName,
+        uiCultureName: formState.uiCultureName || formState.cultureName,
+        displayName: formState.displayName.trim(),
+        flagIcon: formState.flagIcon,
+        isEnabled: formState.isEnabled
+      };
+      result = await createLanguage(createData);
+      if (result.success) {
+        onLanguageCreated?.({
+          id: "",
+          creationTime: (/* @__PURE__ */ new Date()).toISOString(),
+          creatorId: "",
+          isDefaultLanguage: false,
+          ...createData
+        });
+      }
+    }
+    setIsSubmitting(false);
+    if (result.success) {
+      setIsModalOpen(false);
+      setFormState(DEFAULT_FORM_STATE);
+      setSelectedLanguage(null);
+      setIsEditing(false);
+    }
+  }, [
+    formState,
+    isEditing,
+    selectedLanguage,
+    updateLanguage,
+    createLanguage,
+    onLanguageCreated,
+    onLanguageUpdated,
+    setSelectedLanguage
+  ]);
+  const handleModalClose = useCallback3(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE);
+    setSelectedLanguage(null);
+    setIsEditing(false);
+  }, [setSelectedLanguage]);
+  const handleInputChange = useCallback3(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handleCultureChange = useCallback3(
+    (cultureName) => {
+      setFormState((prev) => ({
+        ...prev,
+        cultureName,
+        uiCultureName: cultureName
+      }));
+      const culture = cultures.find((c) => c.name === cultureName);
+      if (culture) {
+        setFormState((prev) => ({
+          ...prev,
+          displayName: culture.displayName
+        }));
+      }
+    },
+    [cultures]
+  );
+  return /* @__PURE__ */ jsxs(Box, { id: "language-management-languages-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("AbpLanguageManagement::Languages") || "Languages" }),
+      /* @__PURE__ */ jsx(Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpLanguageManagement::NewLanguage") || "New Language" })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { mb: 4, children: /* @__PURE__ */ jsx(
+      Input,
+      {
+        placeholder: t("AbpLanguageManagement::Search") || "Search...",
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ jsx(Alert, { status: "error", mb: 4, children: error }),
+    isLoading && languages.length === 0 && /* @__PURE__ */ jsx(Flex, { justify: "center", py: 8, children: /* @__PURE__ */ jsx(Spinner, { size: "lg" }) }),
+    languages.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("AbpLanguageManagement::Actions") || "Actions" }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpLanguageManagement::DisplayName") || "Display Name" }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpLanguageManagement::CultureName") || "Culture Name" }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpLanguageManagement::UiCultureName") || "UI Culture Name" }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpLanguageManagement::IsEnabled") || "Enabled" }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpLanguageManagement::IsDefaultLanguage") || "Default" })
+      ] }) }),
+      /* @__PURE__ */ jsx(Table.Body, { children: filteredLanguages.map((language) => /* @__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("AbpLanguageManagement::Actions") || "Actions" }) }),
+          /* @__PURE__ */ jsx(Menu.Positioner, { children: /* @__PURE__ */ jsxs(Menu.Content, { children: [
+            /* @__PURE__ */ jsx(Menu.Item, { value: "edit", onClick: () => handleEdit(language.id), children: t("AbpLanguageManagement::Edit") || "Edit" }),
+            !language.isDefaultLanguage && /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                Menu.Item,
+                {
+                  value: "setDefault",
+                  onClick: () => handleSetAsDefault(language.id),
+                  children: t("AbpLanguageManagement::SetAsDefaultLanguage") || "Set as Default"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Menu.Item,
+                {
+                  value: "delete",
+                  color: "red.500",
+                  onClick: () => handleDelete(language.id, language.displayName),
+                  children: t("AbpLanguageManagement::Delete") || "Delete"
+                }
+              )
+            ] })
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: /* @__PURE__ */ jsxs(Flex, { align: "center", gap: 2, children: [
+          language.flagIcon && /* @__PURE__ */ jsx(Text, { children: language.flagIcon }),
+          language.displayName
+        ] }) }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: language.cultureName }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: language.uiCultureName }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: /* @__PURE__ */ jsx(Badge, { colorPalette: language.isEnabled ? "green" : "red", children: language.isEnabled ? t("AbpLanguageManagement::Yes") || "Yes" : t("AbpLanguageManagement::No") || "No" }) }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: language.isDefaultLanguage && /* @__PURE__ */ jsx(Badge, { colorPalette: "blue", children: t("AbpLanguageManagement::Default") || "Default" }) })
+      ] }, language.id)) })
+    ] }),
+    !isLoading && languages.length === 0 && /* @__PURE__ */ jsx(Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpLanguageManagement::NoLanguagesFound") || "No languages found" }),
+    /* @__PURE__ */ jsx(
+      Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: isEditing ? t("AbpLanguageManagement::Edit") || "Edit" : t("AbpLanguageManagement::NewLanguage") || "New Language",
+        footer: /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpLanguageManagement::Cancel") || "Cancel" }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.displayName.trim() || !isEditing && !formState.cultureName,
+              children: t("AbpLanguageManagement::Save") || "Save"
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+          !isEditing && /* @__PURE__ */ jsx(FormField, { label: t("AbpLanguageManagement::CultureName") || "Culture", required: true, children: /* @__PURE__ */ jsx(NativeSelectRoot, { children: /* @__PURE__ */ jsxs(
+            NativeSelectField,
+            {
+              value: formState.cultureName,
+              onChange: (e) => handleCultureChange(e.target.value),
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: t("AbpLanguageManagement::SelectCulture") || "Select a culture..." }),
+                cultures.map((culture) => /* @__PURE__ */ jsxs("option", { value: culture.name, children: [
+                  culture.displayName,
+                  " (",
+                  culture.name,
+                  ")"
+                ] }, culture.name))
+              ]
+            }
+          ) }) }),
+          !isEditing && /* @__PURE__ */ jsx(FormField, { label: t("AbpLanguageManagement::UiCultureName") || "UI Culture", children: /* @__PURE__ */ jsx(NativeSelectRoot, { children: /* @__PURE__ */ jsxs(
+            NativeSelectField,
+            {
+              value: formState.uiCultureName,
+              onChange: (e) => handleInputChange("uiCultureName", e.target.value),
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: t("AbpLanguageManagement::SameAsCulture") || "Same as culture" }),
+                cultures.map((culture) => /* @__PURE__ */ jsxs("option", { value: culture.name, children: [
+                  culture.displayName,
+                  " (",
+                  culture.name,
+                  ")"
+                ] }, culture.name))
+              ]
+            }
+          ) }) }),
+          /* @__PURE__ */ jsx(FormField, { label: t("AbpLanguageManagement::DisplayName") || "Display Name", required: true, children: /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: formState.displayName,
+              onChange: (e) => handleInputChange("displayName", e.target.value),
+              maxLength: 128,
+              placeholder: t("AbpLanguageManagement::DisplayName") || "Display Name"
+            }
+          ) }),
+          /* @__PURE__ */ jsx(FormField, { label: t("AbpLanguageManagement::FlagIcon") || "Flag Icon", children: /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: formState.flagIcon,
+              onChange: (e) => handleInputChange("flagIcon", e.target.value),
+              maxLength: 48,
+              placeholder: t("AbpLanguageManagement::FlagIcon") || "Flag icon (e.g., emoji)"
+            }
+          ) }),
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(
+            Checkbox.Root,
+            {
+              checked: formState.isEnabled,
+              onCheckedChange: (e) => handleInputChange("isEnabled", !!e.checked),
+              children: [
+                /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                /* @__PURE__ */ jsx(Checkbox.Control, {}),
+                /* @__PURE__ */ jsx(Checkbox.Label, { children: t("AbpLanguageManagement::IsEnabled") || "Enabled" })
+              ]
+            }
+          ) })
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/components/LanguageTexts/LanguageTextsComponent.tsx
+import { useEffect as useEffect2, useState as useState4, useCallback as useCallback4 } 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, FormField as FormField2 } from "@abpjs/theme-shared";
+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,
+  Textarea,
+  HStack
+} from "@chakra-ui/react";
+import { NativeSelectRoot as NativeSelectRoot2, NativeSelectField as NativeSelectField2 } from "@chakra-ui/react";
+import { Checkbox as Checkbox2 } from "@chakra-ui/react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var DEFAULT_FILTER_STATE = {
+  resourceName: "",
+  baseCultureName: "",
+  targetCultureName: "",
+  filter: "",
+  getOnlyEmptyValues: false
+};
+function LanguageTextsComponent({
+  onLanguageTextUpdated,
+  onLanguageTextRestored
+}) {
+  const { t } = useLocalization2();
+  const confirmation = useConfirmation2();
+  const { languages, fetchLanguages } = useLanguages();
+  const {
+    languageTexts,
+    totalCount,
+    resources,
+    selectedLanguageText,
+    isLoading,
+    error,
+    fetchLanguageTexts,
+    fetchResources,
+    updateLanguageTextByName,
+    restoreLanguageTextByName,
+    setSelectedLanguageText
+  } = useLanguageTexts();
+  const [filterState, setFilterState] = useState4(DEFAULT_FILTER_STATE);
+  const [isModalOpen, setIsModalOpen] = useState4(false);
+  const [editValue, setEditValue] = useState4("");
+  const [isSubmitting, setIsSubmitting] = useState4(false);
+  const [currentPage, setCurrentPage] = useState4(0);
+  const [pageSize] = useState4(10);
+  useEffect2(() => {
+    fetchLanguages();
+    fetchResources();
+  }, [fetchLanguages, fetchResources]);
+  useEffect2(() => {
+    if (languages.length > 0 && !filterState.baseCultureName) {
+      const defaultLanguage = languages.find((l) => l.isDefaultLanguage);
+      const baseCulture = defaultLanguage?.cultureName || languages[0]?.cultureName || "en";
+      const targetCulture = languages.find((l) => !l.isDefaultLanguage)?.cultureName || baseCulture;
+      setFilterState((prev) => ({
+        ...prev,
+        baseCultureName: baseCulture,
+        targetCultureName: targetCulture
+      }));
+    }
+  }, [languages, filterState.baseCultureName]);
+  const loadLanguageTexts = useCallback4(
+    async (page = currentPage) => {
+      if (!filterState.baseCultureName || !filterState.targetCultureName) return;
+      await fetchLanguageTexts({
+        resourceName: filterState.resourceName || void 0,
+        baseCultureName: filterState.baseCultureName,
+        targetCultureName: filterState.targetCultureName,
+        getOnlyEmptyValues: filterState.getOnlyEmptyValues,
+        filter: filterState.filter || void 0,
+        skipCount: page * pageSize,
+        maxResultCount: pageSize
+      });
+    },
+    [filterState, currentPage, pageSize, fetchLanguageTexts]
+  );
+  useEffect2(() => {
+    if (filterState.baseCultureName && filterState.targetCultureName) {
+      setCurrentPage(0);
+      loadLanguageTexts(0);
+    }
+  }, [
+    filterState.baseCultureName,
+    filterState.targetCultureName,
+    filterState.resourceName,
+    filterState.getOnlyEmptyValues
+  ]);
+  const handleSearch = useCallback4(() => {
+    setCurrentPage(0);
+    loadLanguageTexts(0);
+  }, [loadLanguageTexts]);
+  const handleEdit = useCallback4(
+    (languageText) => {
+      setSelectedLanguageText(languageText);
+      setEditValue(languageText.value || "");
+      setIsModalOpen(true);
+    },
+    [setSelectedLanguageText]
+  );
+  const handleRestore = useCallback4(
+    async (languageText) => {
+      const status = await confirmation.warn(
+        t("AbpLanguageManagement::RestoreToDefaultConfirmationMessage") || "Are you sure you want to restore this text to its default value?",
+        t("AbpLanguageManagement::AreYouSure") || "Are you sure?"
+      );
+      if (status === Toaster2.Status.confirm) {
+        const params = {
+          resourceName: languageText.resourceName,
+          cultureName: languageText.cultureName,
+          name: languageText.name
+        };
+        const result = await restoreLanguageTextByName(params);
+        if (result.success) {
+          onLanguageTextRestored?.(params);
+        }
+      }
+    },
+    [confirmation, t, restoreLanguageTextByName, onLanguageTextRestored]
+  );
+  const handleSubmit = useCallback4(async () => {
+    if (!selectedLanguageText) return;
+    setIsSubmitting(true);
+    const params = {
+      resourceName: selectedLanguageText.resourceName,
+      cultureName: selectedLanguageText.cultureName,
+      name: selectedLanguageText.name,
+      value: editValue
+    };
+    const result = await updateLanguageTextByName(params);
+    setIsSubmitting(false);
+    if (result.success) {
+      onLanguageTextUpdated?.(params);
+      setIsModalOpen(false);
+      setSelectedLanguageText(null);
+      setEditValue("");
+    }
+  }, [selectedLanguageText, editValue, updateLanguageTextByName, onLanguageTextUpdated, setSelectedLanguageText]);
+  const handleModalClose = useCallback4(() => {
+    setIsModalOpen(false);
+    setSelectedLanguageText(null);
+    setEditValue("");
+  }, [setSelectedLanguageText]);
+  const handleFilterChange = useCallback4(
+    (field, value) => {
+      setFilterState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handlePageChange = useCallback4(
+    (newPage) => {
+      setCurrentPage(newPage);
+      loadLanguageTexts(newPage);
+    },
+    [loadLanguageTexts]
+  );
+  const totalPages = Math.ceil(totalCount / pageSize);
+  return /* @__PURE__ */ jsxs2(Box2, { id: "language-management-texts-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ jsx2(Flex2, { justify: "space-between", align: "center", mb: 4, children: /* @__PURE__ */ jsx2(Text2, { fontSize: "xl", fontWeight: "bold", children: t("AbpLanguageManagement::LanguageTexts") || "Language Texts" }) }),
+    /* @__PURE__ */ jsxs2(VStack2, { gap: 4, align: "stretch", mb: 4, children: [
+      /* @__PURE__ */ jsxs2(HStack, { gap: 4, flexWrap: "wrap", children: [
+        /* @__PURE__ */ jsx2(Box2, { flex: "1", minW: "200px", children: /* @__PURE__ */ jsx2(FormField2, { label: t("AbpLanguageManagement::Resource") || "Resource", children: /* @__PURE__ */ jsx2(NativeSelectRoot2, { children: /* @__PURE__ */ jsxs2(
+          NativeSelectField2,
+          {
+            value: filterState.resourceName,
+            onChange: (e) => handleFilterChange("resourceName", e.target.value),
+            children: [
+              /* @__PURE__ */ jsx2("option", { value: "", children: t("AbpLanguageManagement::AllResources") || "All Resources" }),
+              resources.map((resource) => /* @__PURE__ */ jsx2("option", { value: resource.name, children: resource.name }, resource.name))
+            ]
+          }
+        ) }) }) }),
+        /* @__PURE__ */ jsx2(Box2, { flex: "1", minW: "200px", children: /* @__PURE__ */ jsx2(FormField2, { label: t("AbpLanguageManagement::BaseCulture") || "Base Culture", children: /* @__PURE__ */ jsx2(NativeSelectRoot2, { children: /* @__PURE__ */ jsx2(
+          NativeSelectField2,
+          {
+            value: filterState.baseCultureName,
+            onChange: (e) => handleFilterChange("baseCultureName", e.target.value),
+            children: languages.map((lang) => /* @__PURE__ */ jsxs2("option", { value: lang.cultureName, children: [
+              lang.displayName,
+              " (",
+              lang.cultureName,
+              ")"
+            ] }, lang.cultureName))
+          }
+        ) }) }) }),
+        /* @__PURE__ */ jsx2(Box2, { flex: "1", minW: "200px", children: /* @__PURE__ */ jsx2(FormField2, { label: t("AbpLanguageManagement::TargetCulture") || "Target Culture", children: /* @__PURE__ */ jsx2(NativeSelectRoot2, { children: /* @__PURE__ */ jsx2(
+          NativeSelectField2,
+          {
+            value: filterState.targetCultureName,
+            onChange: (e) => handleFilterChange("targetCultureName", e.target.value),
+            children: languages.map((lang) => /* @__PURE__ */ jsxs2("option", { value: lang.cultureName, children: [
+              lang.displayName,
+              " (",
+              lang.cultureName,
+              ")"
+            ] }, lang.cultureName))
+          }
+        ) }) }) })
+      ] }),
+      /* @__PURE__ */ jsxs2(HStack, { gap: 4, children: [
+        /* @__PURE__ */ jsx2(
+          Input2,
+          {
+            placeholder: t("AbpLanguageManagement::Filter") || "Filter by key or value...",
+            value: filterState.filter,
+            onChange: (e) => handleFilterChange("filter", e.target.value),
+            onKeyDown: (e) => e.key === "Enter" && handleSearch(),
+            flex: "1"
+          }
+        ),
+        /* @__PURE__ */ jsxs2(
+          Checkbox2.Root,
+          {
+            checked: filterState.getOnlyEmptyValues,
+            onCheckedChange: (e) => handleFilterChange("getOnlyEmptyValues", !!e.checked),
+            children: [
+              /* @__PURE__ */ jsx2(Checkbox2.HiddenInput, {}),
+              /* @__PURE__ */ jsx2(Checkbox2.Control, {}),
+              /* @__PURE__ */ jsx2(Checkbox2.Label, { children: t("AbpLanguageManagement::OnlyEmptyValues") || "Only empty values" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx2(Button2, { colorPalette: "blue", onClick: handleSearch, children: t("AbpLanguageManagement::Search") || "Search" })
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsx2(Alert2, { status: "error", mb: 4, children: error }),
+    isLoading && languageTexts.length === 0 && /* @__PURE__ */ jsx2(Flex2, { justify: "center", py: 8, children: /* @__PURE__ */ jsx2(Spinner2, { size: "lg" }) }),
+    languageTexts.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("AbpLanguageManagement::Actions") || "Actions" }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpLanguageManagement::Key") || "Key" }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpLanguageManagement::BaseValue") || "Base Value" }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpLanguageManagement::TargetValue") || "Target Value" }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpLanguageManagement::Resource") || "Resource" })
+        ] }) }),
+        /* @__PURE__ */ jsx2(Table2.Body, { children: languageTexts.map((text, index) => /* @__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("AbpLanguageManagement::Actions") || "Actions" }) }),
+            /* @__PURE__ */ jsx2(Menu2.Positioner, { children: /* @__PURE__ */ jsxs2(Menu2.Content, { children: [
+              /* @__PURE__ */ jsx2(Menu2.Item, { value: "edit", onClick: () => handleEdit(text), children: t("AbpLanguageManagement::Edit") || "Edit" }),
+              text.value !== text.baseValue && /* @__PURE__ */ jsx2(
+                Menu2.Item,
+                {
+                  value: "restore",
+                  color: "orange.500",
+                  onClick: () => handleRestore(text),
+                  children: t("AbpLanguageManagement::RestoreToDefault") || "Restore to Default"
+                }
+              )
+            ] }) })
+          ] }) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsx2(Text2, { fontSize: "sm", fontFamily: "mono", children: text.name }) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsx2(Text2, { fontSize: "sm", color: "gray.600", children: text.baseValue }) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsx2(
+            Text2,
+            {
+              fontSize: "sm",
+              color: text.value ? "inherit" : "red.500",
+              fontStyle: text.value ? "normal" : "italic",
+              children: text.value || t("AbpLanguageManagement::NotTranslated") || "(Not translated)"
+            }
+          ) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsx2(Text2, { fontSize: "sm", color: "gray.500", children: text.resourceName }) })
+        ] }, `${text.resourceName}-${text.name}-${index}`)) })
+      ] }),
+      totalPages > 1 && /* @__PURE__ */ jsxs2(Flex2, { justify: "space-between", align: "center", mt: 4, children: [
+        /* @__PURE__ */ jsx2(Text2, { fontSize: "sm", color: "gray.500", children: t("AbpLanguageManagement::ShowingXofY", (currentPage * pageSize + 1).toString(), Math.min((currentPage + 1) * pageSize, totalCount).toString(), totalCount.toString()) || `Showing ${currentPage * pageSize + 1}-${Math.min((currentPage + 1) * pageSize, totalCount)} of ${totalCount}` }),
+        /* @__PURE__ */ jsxs2(HStack, { gap: 2, children: [
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: () => handlePageChange(currentPage - 1),
+              disabled: currentPage === 0,
+              children: t("AbpLanguageManagement::Previous") || "Previous"
+            }
+          ),
+          /* @__PURE__ */ jsxs2(Text2, { fontSize: "sm", children: [
+            currentPage + 1,
+            " / ",
+            totalPages
+          ] }),
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: () => handlePageChange(currentPage + 1),
+              disabled: currentPage >= totalPages - 1,
+              children: t("AbpLanguageManagement::Next") || "Next"
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    !isLoading && languageTexts.length === 0 && filterState.baseCultureName && filterState.targetCultureName && /* @__PURE__ */ jsx2(Text2, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpLanguageManagement::NoLanguageTextsFound") || "No language texts found" }),
+    !filterState.baseCultureName || !filterState.targetCultureName ? /* @__PURE__ */ jsx2(Text2, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpLanguageManagement::SelectCulturesToViewTexts") || "Select base and target cultures to view language texts" }) : null,
+    /* @__PURE__ */ jsx2(
+      Modal2,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: t("AbpLanguageManagement::EditLanguageText") || "Edit Language Text",
+        footer: /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx2(Button2, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpLanguageManagement::Cancel") || "Cancel" }),
+          /* @__PURE__ */ jsx2(Button2, { colorPalette: "blue", onClick: handleSubmit, loading: isSubmitting, children: t("AbpLanguageManagement::Save") || "Save" })
+        ] }),
+        children: /* @__PURE__ */ jsx2(VStack2, { gap: 4, align: "stretch", children: selectedLanguageText && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx2(FormField2, { label: t("AbpLanguageManagement::Key") || "Key", children: /* @__PURE__ */ jsx2(Text2, { fontFamily: "mono", p: 2, bg: "gray.100", borderRadius: "md", children: selectedLanguageText.name }) }),
+          /* @__PURE__ */ jsx2(FormField2, { label: t("AbpLanguageManagement::BaseValue") || "Base Value", children: /* @__PURE__ */ jsx2(Text2, { p: 2, bg: "gray.100", borderRadius: "md", color: "gray.600", children: selectedLanguageText.baseValue }) }),
+          /* @__PURE__ */ jsx2(FormField2, { label: t("AbpLanguageManagement::TargetValue") || "Target Value", children: /* @__PURE__ */ jsx2(
+            Textarea,
+            {
+              value: editValue,
+              onChange: (e) => setEditValue(e.target.value),
+              placeholder: t("AbpLanguageManagement::EnterTranslation") || "Enter translation...",
+              rows: 4
+            }
+          ) })
+        ] }) })
+      }
+    )
+  ] });
+}
+export {
+  LANGUAGE_MANAGEMENT_ROUTES,
+  LanguageManagementService,
+  LanguageTextsComponent,
+  LanguagesComponent,
+  useLanguageTexts,
+  useLanguages
+};