@abpjs/language-management 0.7.2

package/dist/index.js

@@ -0,0 +1,1186 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LANGUAGE_MANAGEMENT_ROUTES: () => LANGUAGE_MANAGEMENT_ROUTES,
+  LanguageManagementService: () => LanguageManagementService,
+  LanguageTextsComponent: () => LanguageTextsComponent,
+  LanguagesComponent: () => LanguagesComponent,
+  useLanguageTexts: () => useLanguageTexts,
+  useLanguages: () => useLanguages
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_react = require("react");
+var import_core = require("@abpjs/core");
+function useLanguages() {
+  const restService = (0, import_core.useRestService)();
+  const service = (0, import_react.useMemo)(() => new LanguageManagementService(restService), [restService]);
+  const [languages, setLanguages] = (0, import_react.useState)([]);
+  const [totalCount, setTotalCount] = (0, import_react.useState)(0);
+  const [cultures, setCultures] = (0, import_react.useState)([]);
+  const [selectedLanguage, setSelectedLanguage] = (0, import_react.useState)(
+    null
+  );
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [sortKey, setSortKey] = (0, import_react.useState)("displayName");
+  const [sortOrder, setSortOrder] = (0, import_react.useState)("");
+  const fetchLanguages = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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
+var import_react2 = require("react");
+var import_core2 = require("@abpjs/core");
+function useLanguageTexts() {
+  const restService = (0, import_core2.useRestService)();
+  const service = (0, import_react2.useMemo)(() => new LanguageManagementService(restService), [restService]);
+  const [languageTexts, setLanguageTexts] = (0, import_react2.useState)([]);
+  const [totalCount, setTotalCount] = (0, import_react2.useState)(0);
+  const [resources, setResources] = (0, import_react2.useState)([]);
+  const [selectedLanguageText, setSelectedLanguageText] = (0, import_react2.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [sortKey, setSortKey] = (0, import_react2.useState)("name");
+  const [sortOrder, setSortOrder] = (0, import_react2.useState)("");
+  const [lastQueryParams, setLastQueryParams] = (0, import_react2.useState)(null);
+  const fetchLanguageTexts = (0, import_react2.useCallback)(
+    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 = (0, import_react2.useCallback)(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 = (0, import_react2.useCallback)(
+    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 = (0, import_react2.useCallback)(
+    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 = (0, import_react2.useCallback)(
+    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 = (0, import_react2.useCallback)(() => {
+    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
+var import_react3 = require("react");
+var import_core3 = require("@abpjs/core");
+var import_theme_shared = require("@abpjs/theme-shared");
+var import_react4 = require("@chakra-ui/react");
+var import_react5 = require("@chakra-ui/react");
+var import_react6 = require("@chakra-ui/react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DEFAULT_FORM_STATE = {
+  cultureName: "",
+  uiCultureName: "",
+  displayName: "",
+  flagIcon: "",
+  isEnabled: true
+};
+function LanguagesComponent({
+  onLanguageCreated,
+  onLanguageUpdated,
+  onLanguageDeleted
+}) {
+  const { t } = (0, import_core3.useLocalization)();
+  const confirmation = (0, import_theme_shared.useConfirmation)();
+  const {
+    languages,
+    cultures,
+    selectedLanguage,
+    isLoading,
+    error,
+    fetchLanguages,
+    fetchCultures,
+    getLanguageById,
+    createLanguage,
+    updateLanguage,
+    deleteLanguage,
+    setAsDefaultLanguage,
+    setSelectedLanguage
+  } = useLanguages();
+  const [isModalOpen, setIsModalOpen] = (0, import_react3.useState)(false);
+  const [formState, setFormState] = (0, import_react3.useState)(DEFAULT_FORM_STATE);
+  const [isSubmitting, setIsSubmitting] = (0, import_react3.useState)(false);
+  const [isEditing, setIsEditing] = (0, import_react3.useState)(false);
+  const [searchTerm, setSearchTerm] = (0, import_react3.useState)("");
+  (0, import_react3.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 = (0, import_react3.useCallback)(() => {
+    setSelectedLanguage(null);
+    setFormState(DEFAULT_FORM_STATE);
+    setIsEditing(false);
+    setIsModalOpen(true);
+  }, [setSelectedLanguage]);
+  const handleEdit = (0, import_react3.useCallback)(
+    async (id) => {
+      const result = await getLanguageById(id);
+      if (result.success) {
+        setIsEditing(true);
+        setIsModalOpen(true);
+      }
+    },
+    [getLanguageById]
+  );
+  (0, import_react3.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 = (0, import_react3.useCallback)(
+    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 === import_theme_shared.Toaster.Status.confirm) {
+        const result = await deleteLanguage(id);
+        if (result.success) {
+          onLanguageDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteLanguage, onLanguageDeleted]
+  );
+  const handleSetAsDefault = (0, import_react3.useCallback)(
+    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 === import_theme_shared.Toaster.Status.confirm) {
+        await setAsDefaultLanguage(id);
+      }
+    },
+    [confirmation, t, setAsDefaultLanguage]
+  );
+  const handleSubmit = (0, import_react3.useCallback)(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 = (0, import_react3.useCallback)(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE);
+    setSelectedLanguage(null);
+    setIsEditing(false);
+  }, [setSelectedLanguage]);
+  const handleInputChange = (0, import_react3.useCallback)(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handleCultureChange = (0, import_react3.useCallback)(
+    (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__ */ (0, import_jsx_runtime.jsxs)(import_react4.Box, { id: "language-management-languages-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Flex, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpLanguageManagement::Languages") || "Languages" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpLanguageManagement::NewLanguage") || "New Language" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Box, { mb: 4, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_react4.Input,
+      {
+        placeholder: t("AbpLanguageManagement::Search") || "Search...",
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Alert, { status: "error", mb: 4, children: error }),
+    isLoading && languages.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Flex, { justify: "center", py: 8, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Spinner, { size: "lg" }) }),
+    languages.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Table.Root, { variant: "outline", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Header, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Table.Row, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.ColumnHeader, { children: t("AbpLanguageManagement::Actions") || "Actions" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.ColumnHeader, { children: t("AbpLanguageManagement::DisplayName") || "Display Name" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.ColumnHeader, { children: t("AbpLanguageManagement::CultureName") || "Culture Name" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.ColumnHeader, { children: t("AbpLanguageManagement::UiCultureName") || "UI Culture Name" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.ColumnHeader, { children: t("AbpLanguageManagement::IsEnabled") || "Enabled" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.ColumnHeader, { children: t("AbpLanguageManagement::IsDefaultLanguage") || "Default" })
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Body, { children: filteredLanguages.map((language) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Table.Row, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Menu.Root, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Menu.Trigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Button, { size: "sm", colorPalette: "blue", children: t("AbpLanguageManagement::Actions") || "Actions" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Menu.Positioner, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Menu.Content, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Menu.Item, { value: "edit", onClick: () => handleEdit(language.id), children: t("AbpLanguageManagement::Edit") || "Edit" }),
+            !language.isDefaultLanguage && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                import_react4.Menu.Item,
+                {
+                  value: "setDefault",
+                  onClick: () => handleSetAsDefault(language.id),
+                  children: t("AbpLanguageManagement::SetAsDefaultLanguage") || "Set as Default"
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                import_react4.Menu.Item,
+                {
+                  value: "delete",
+                  color: "red.500",
+                  onClick: () => handleDelete(language.id, language.displayName),
+                  children: t("AbpLanguageManagement::Delete") || "Delete"
+                }
+              )
+            ] })
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.Flex, { align: "center", gap: 2, children: [
+          language.flagIcon && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Text, { children: language.flagIcon }),
+          language.displayName
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Cell, { children: language.cultureName }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Cell, { children: language.uiCultureName }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Badge, { colorPalette: language.isEnabled ? "green" : "red", children: language.isEnabled ? t("AbpLanguageManagement::Yes") || "Yes" : t("AbpLanguageManagement::No") || "No" }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Table.Cell, { children: language.isDefaultLanguage && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Badge, { colorPalette: "blue", children: t("AbpLanguageManagement::Default") || "Default" }) })
+      ] }, language.id)) })
+    ] }),
+    !isLoading && languages.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpLanguageManagement::NoLanguagesFound") || "No languages found" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_theme_shared.Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: isEditing ? t("AbpLanguageManagement::Edit") || "Edit" : t("AbpLanguageManagement::NewLanguage") || "New Language",
+        footer: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpLanguageManagement::Cancel") || "Cancel" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_theme_shared.Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.displayName.trim() || !isEditing && !formState.cultureName,
+              children: t("AbpLanguageManagement::Save") || "Save"
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react4.VStack, { gap: 4, align: "stretch", children: [
+          !isEditing && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.FormField, { label: t("AbpLanguageManagement::CultureName") || "Culture", required: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react5.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+            import_react5.NativeSelectField,
+            {
+              value: formState.cultureName,
+              onChange: (e) => handleCultureChange(e.target.value),
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "", children: t("AbpLanguageManagement::SelectCulture") || "Select a culture..." }),
+                cultures.map((culture) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("option", { value: culture.name, children: [
+                  culture.displayName,
+                  " (",
+                  culture.name,
+                  ")"
+                ] }, culture.name))
+              ]
+            }
+          ) }) }),
+          !isEditing && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.FormField, { label: t("AbpLanguageManagement::UiCultureName") || "UI Culture", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react5.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+            import_react5.NativeSelectField,
+            {
+              value: formState.uiCultureName,
+              onChange: (e) => handleInputChange("uiCultureName", e.target.value),
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "", children: t("AbpLanguageManagement::SameAsCulture") || "Same as culture" }),
+                cultures.map((culture) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("option", { value: culture.name, children: [
+                  culture.displayName,
+                  " (",
+                  culture.name,
+                  ")"
+                ] }, culture.name))
+              ]
+            }
+          ) }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.FormField, { label: t("AbpLanguageManagement::DisplayName") || "Display Name", required: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_react4.Input,
+            {
+              value: formState.displayName,
+              onChange: (e) => handleInputChange("displayName", e.target.value),
+              maxLength: 128,
+              placeholder: t("AbpLanguageManagement::DisplayName") || "Display Name"
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.FormField, { label: t("AbpLanguageManagement::FlagIcon") || "Flag Icon", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_react4.Input,
+            {
+              value: formState.flagIcon,
+              onChange: (e) => handleInputChange("flagIcon", e.target.value),
+              maxLength: 48,
+              placeholder: t("AbpLanguageManagement::FlagIcon") || "Flag icon (e.g., emoji)"
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react4.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+            import_react6.Checkbox.Root,
+            {
+              checked: formState.isEnabled,
+              onCheckedChange: (e) => handleInputChange("isEnabled", !!e.checked),
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Checkbox.HiddenInput, {}),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Checkbox.Control, {}),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Checkbox.Label, { children: t("AbpLanguageManagement::IsEnabled") || "Enabled" })
+              ]
+            }
+          ) })
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/components/LanguageTexts/LanguageTextsComponent.tsx
+var import_react7 = require("react");
+var import_core4 = require("@abpjs/core");
+var import_theme_shared2 = require("@abpjs/theme-shared");
+var import_react8 = require("@chakra-ui/react");
+var import_react9 = require("@chakra-ui/react");
+var import_react10 = require("@chakra-ui/react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var DEFAULT_FILTER_STATE = {
+  resourceName: "",
+  baseCultureName: "",
+  targetCultureName: "",
+  filter: "",
+  getOnlyEmptyValues: false
+};
+function LanguageTextsComponent({
+  onLanguageTextUpdated,
+  onLanguageTextRestored
+}) {
+  const { t } = (0, import_core4.useLocalization)();
+  const confirmation = (0, import_theme_shared2.useConfirmation)();
+  const { languages, fetchLanguages } = useLanguages();
+  const {
+    languageTexts,
+    totalCount,
+    resources,
+    selectedLanguageText,
+    isLoading,
+    error,
+    fetchLanguageTexts,
+    fetchResources,
+    updateLanguageTextByName,
+    restoreLanguageTextByName,
+    setSelectedLanguageText
+  } = useLanguageTexts();
+  const [filterState, setFilterState] = (0, import_react7.useState)(DEFAULT_FILTER_STATE);
+  const [isModalOpen, setIsModalOpen] = (0, import_react7.useState)(false);
+  const [editValue, setEditValue] = (0, import_react7.useState)("");
+  const [isSubmitting, setIsSubmitting] = (0, import_react7.useState)(false);
+  const [currentPage, setCurrentPage] = (0, import_react7.useState)(0);
+  const [pageSize] = (0, import_react7.useState)(10);
+  (0, import_react7.useEffect)(() => {
+    fetchLanguages();
+    fetchResources();
+  }, [fetchLanguages, fetchResources]);
+  (0, import_react7.useEffect)(() => {
+    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 = (0, import_react7.useCallback)(
+    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]
+  );
+  (0, import_react7.useEffect)(() => {
+    if (filterState.baseCultureName && filterState.targetCultureName) {
+      setCurrentPage(0);
+      loadLanguageTexts(0);
+    }
+  }, [
+    filterState.baseCultureName,
+    filterState.targetCultureName,
+    filterState.resourceName,
+    filterState.getOnlyEmptyValues
+  ]);
+  const handleSearch = (0, import_react7.useCallback)(() => {
+    setCurrentPage(0);
+    loadLanguageTexts(0);
+  }, [loadLanguageTexts]);
+  const handleEdit = (0, import_react7.useCallback)(
+    (languageText) => {
+      setSelectedLanguageText(languageText);
+      setEditValue(languageText.value || "");
+      setIsModalOpen(true);
+    },
+    [setSelectedLanguageText]
+  );
+  const handleRestore = (0, import_react7.useCallback)(
+    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 === import_theme_shared2.Toaster.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 = (0, import_react7.useCallback)(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 = (0, import_react7.useCallback)(() => {
+    setIsModalOpen(false);
+    setSelectedLanguageText(null);
+    setEditValue("");
+  }, [setSelectedLanguageText]);
+  const handleFilterChange = (0, import_react7.useCallback)(
+    (field, value) => {
+      setFilterState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handlePageChange = (0, import_react7.useCallback)(
+    (newPage) => {
+      setCurrentPage(newPage);
+      loadLanguageTexts(newPage);
+    },
+    [loadLanguageTexts]
+  );
+  const totalPages = Math.ceil(totalCount / pageSize);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Box, { id: "language-management-texts-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Flex, { justify: "space-between", align: "center", mb: 4, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpLanguageManagement::LanguageTexts") || "Language Texts" }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.VStack, { gap: 4, align: "stretch", mb: 4, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.HStack, { gap: 4, flexWrap: "wrap", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Box, { flex: "1", minW: "200px", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpLanguageManagement::Resource") || "Resource", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react9.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+          import_react9.NativeSelectField,
+          {
+            value: filterState.resourceName,
+            onChange: (e) => handleFilterChange("resourceName", e.target.value),
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("option", { value: "", children: t("AbpLanguageManagement::AllResources") || "All Resources" }),
+              resources.map((resource) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("option", { value: resource.name, children: resource.name }, resource.name))
+            ]
+          }
+        ) }) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Box, { flex: "1", minW: "200px", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpLanguageManagement::BaseCulture") || "Base Culture", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react9.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          import_react9.NativeSelectField,
+          {
+            value: filterState.baseCultureName,
+            onChange: (e) => handleFilterChange("baseCultureName", e.target.value),
+            children: languages.map((lang) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("option", { value: lang.cultureName, children: [
+              lang.displayName,
+              " (",
+              lang.cultureName,
+              ")"
+            ] }, lang.cultureName))
+          }
+        ) }) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Box, { flex: "1", minW: "200px", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpLanguageManagement::TargetCulture") || "Target Culture", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react9.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          import_react9.NativeSelectField,
+          {
+            value: filterState.targetCultureName,
+            onChange: (e) => handleFilterChange("targetCultureName", e.target.value),
+            children: languages.map((lang) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("option", { value: lang.cultureName, children: [
+              lang.displayName,
+              " (",
+              lang.cultureName,
+              ")"
+            ] }, lang.cultureName))
+          }
+        ) }) }) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.HStack, { gap: 4, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          import_react8.Input,
+          {
+            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__ */ (0, import_jsx_runtime2.jsxs)(
+          import_react10.Checkbox.Root,
+          {
+            checked: filterState.getOnlyEmptyValues,
+            onCheckedChange: (e) => handleFilterChange("getOnlyEmptyValues", !!e.checked),
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react10.Checkbox.HiddenInput, {}),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react10.Checkbox.Control, {}),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react10.Checkbox.Label, { children: t("AbpLanguageManagement::OnlyEmptyValues") || "Only empty values" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { colorPalette: "blue", onClick: handleSearch, children: t("AbpLanguageManagement::Search") || "Search" })
+      ] })
+    ] }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Alert, { status: "error", mb: 4, children: error }),
+    isLoading && languageTexts.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Flex, { justify: "center", py: 8, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Spinner, { size: "lg" }) }),
+    languageTexts.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Table.Root, { variant: "outline", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Header, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Table.Row, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpLanguageManagement::Actions") || "Actions" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpLanguageManagement::Key") || "Key" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpLanguageManagement::BaseValue") || "Base Value" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpLanguageManagement::TargetValue") || "Target Value" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpLanguageManagement::Resource") || "Resource" })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Body, { children: languageTexts.map((text, index) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Table.Row, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Menu.Root, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Trigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { size: "sm", colorPalette: "blue", children: t("AbpLanguageManagement::Actions") || "Actions" }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Positioner, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Menu.Content, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Item, { value: "edit", onClick: () => handleEdit(text), children: t("AbpLanguageManagement::Edit") || "Edit" }),
+              text.value !== text.baseValue && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                import_react8.Menu.Item,
+                {
+                  value: "restore",
+                  color: "orange.500",
+                  onClick: () => handleRestore(text),
+                  children: t("AbpLanguageManagement::RestoreToDefault") || "Restore to Default"
+                }
+              )
+            ] }) })
+          ] }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { fontSize: "sm", fontFamily: "mono", children: text.name }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { fontSize: "sm", color: "gray.600", children: text.baseValue }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_react8.Text,
+            {
+              fontSize: "sm",
+              color: text.value ? "inherit" : "red.500",
+              fontStyle: text.value ? "normal" : "italic",
+              children: text.value || t("AbpLanguageManagement::NotTranslated") || "(Not translated)"
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { fontSize: "sm", color: "gray.500", children: text.resourceName }) })
+        ] }, `${text.resourceName}-${text.name}-${index}`)) })
+      ] }),
+      totalPages > 1 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Flex, { justify: "space-between", align: "center", mt: 4, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { 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__ */ (0, import_jsx_runtime2.jsxs)(import_react8.HStack, { gap: 2, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_theme_shared2.Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: () => handlePageChange(currentPage - 1),
+              disabled: currentPage === 0,
+              children: t("AbpLanguageManagement::Previous") || "Previous"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Text, { fontSize: "sm", children: [
+            currentPage + 1,
+            " / ",
+            totalPages
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_theme_shared2.Button,
+            {
+              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__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpLanguageManagement::NoLanguageTextsFound") || "No language texts found" }),
+    !filterState.baseCultureName || !filterState.targetCultureName ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpLanguageManagement::SelectCulturesToViewTexts") || "Select base and target cultures to view language texts" }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_theme_shared2.Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: t("AbpLanguageManagement::EditLanguageText") || "Edit Language Text",
+        footer: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpLanguageManagement::Cancel") || "Cancel" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { colorPalette: "blue", onClick: handleSubmit, loading: isSubmitting, children: t("AbpLanguageManagement::Save") || "Save" })
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.VStack, { gap: 4, align: "stretch", children: selectedLanguageText && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpLanguageManagement::Key") || "Key", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { fontFamily: "mono", p: 2, bg: "gray.100", borderRadius: "md", children: selectedLanguageText.name }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpLanguageManagement::BaseValue") || "Base Value", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { p: 2, bg: "gray.100", borderRadius: "md", color: "gray.600", children: selectedLanguageText.baseValue }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpLanguageManagement::TargetValue") || "Target Value", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_react8.Textarea,
+            {
+              value: editValue,
+              onChange: (e) => setEditValue(e.target.value),
+              placeholder: t("AbpLanguageManagement::EnterTranslation") || "Enter translation...",
+              rows: 4
+            }
+          ) })
+        ] }) })
+      }
+    )
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LANGUAGE_MANAGEMENT_ROUTES,
+  LanguageManagementService,
+  LanguageTextsComponent,
+  LanguagesComponent,
+  useLanguageTexts,
+  useLanguages
+});