@abpjs/text-template-management 2.7.0

package/dist/index.mjs

@@ -0,0 +1,794 @@
+// src/enums/components.ts
+var eTextTemplateManagementComponents = {
+  /**
+   * Key for the TextTemplates component.
+   * Use this to replace the default TextTemplates list with a custom implementation.
+   */
+  TextTemplates: "TextTemplateManagement.TextTemplates",
+  /**
+   * Key for the TemplateContents component.
+   * Use this to replace the default template content editor.
+   */
+  TemplateContents: "TextTemplateManagement.TemplateContents",
+  /**
+   * Key for the InlineTemplateContent component.
+   * Use this to replace the inline template content editor.
+   */
+  InlineTemplateContent: "TextTemplateManagement.InlineTemplateContent"
+};
+
+// src/enums/route-names.ts
+var eTextTemplateManagementRouteNames = {
+  /**
+   * Administration route name key.
+   * Used for the administration menu group.
+   */
+  Administration: "AbpUiNavigation::Menu:Administration",
+  /**
+   * Text Templates route name key.
+   * Used for the text templates management route.
+   */
+  TextTemplates: "TextTemplateManagement::Menu:TextTemplates"
+};
+
+// src/constants/routes.ts
+var TEXT_TEMPLATE_MANAGEMENT_ROUTES = {
+  routes: [
+    {
+      name: "TextTemplateManagement::Menu:TextTemplates",
+      path: "text-template-management",
+      layout: "application",
+      order: 100,
+      parentName: "AbpUiNavigation::Menu:Administration"
+    }
+  ]
+};
+
+// src/services/template-definition.service.ts
+var TemplateDefinitionService = class {
+  constructor(restService) {
+    this.restService = restService;
+    /**
+     * API name for multi-API configurations
+     * @since 2.7.0
+     */
+    this.apiName = "default";
+  }
+  /**
+   * Get list of template definitions
+   * @param params Query parameters for filtering and pagination
+   * @returns Promise with list of template definitions
+   */
+  async getList(params = {}) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/text-template-management/template-definitions",
+      params
+    });
+  }
+};
+
+// src/services/template-content.service.ts
+var TemplateContentService = class {
+  constructor(restService) {
+    this.restService = restService;
+    /**
+     * API name for multi-API configurations
+     * @since 2.7.0
+     */
+    this.apiName = "default";
+  }
+  /**
+   * Get template content by input parameters
+   * @param params Input parameters containing template name and optional culture name
+   * @returns Promise with template content
+   */
+  async getByInput(params) {
+    return this.restService.request({
+      method: "GET",
+      url: "/api/text-template-management/template-contents",
+      params
+    });
+  }
+  /**
+   * Restore template content to default
+   * @param body Input containing template name and culture name to restore
+   * @returns Promise that resolves when restore is complete
+   */
+  async restoreToDefaultByInput(body) {
+    return this.restService.request({
+      method: "PUT",
+      url: "/api/text-template-management/template-contents/restore-to-default",
+      body
+    });
+  }
+  /**
+   * Update template content
+   * @param body DTO containing template name, culture name, and new content
+   * @returns Promise with updated template content
+   */
+  async updateByInput(body) {
+    return this.restService.request({
+      method: "PUT",
+      url: "/api/text-template-management/template-contents",
+      body
+    });
+  }
+};
+
+// src/services/text-template-management-state.service.ts
+var TextTemplateManagementStateService = class {
+  constructor(restService) {
+    this._state = {
+      templateDefinitions: [],
+      totalCount: 0,
+      selectedTemplate: null,
+      templateContent: null
+    };
+    this.templateDefinitionService = new TemplateDefinitionService(restService);
+    this.templateContentService = new TemplateContentService(restService);
+  }
+  // ==================== Getters ====================
+  /**
+   * Get template definitions from state
+   * @returns Array of template definitions
+   */
+  getTemplateDefinitions() {
+    return this._state.templateDefinitions;
+  }
+  /**
+   * Get total count of template definitions
+   * @returns Total count
+   */
+  getTotalCount() {
+    return this._state.totalCount;
+  }
+  /**
+   * Get the currently selected template
+   * @returns Selected template or null
+   */
+  getSelectedTemplate() {
+    return this._state.selectedTemplate;
+  }
+  /**
+   * Get template content from state
+   * @returns Template content or null
+   */
+  getTemplateContent() {
+    return this._state.templateContent;
+  }
+  // ==================== Dispatch Methods ====================
+  /**
+   * Dispatch action to fetch template definitions
+   * @param params Query parameters for filtering and pagination
+   * @returns Promise with list result
+   */
+  async dispatchGetTemplateDefinitions(params = {}) {
+    const result = await this.templateDefinitionService.getList(params);
+    this._state.templateDefinitions = result.items || [];
+    this._state.totalCount = this._state.templateDefinitions.length;
+    return result;
+  }
+  /**
+   * Dispatch action to get template content
+   * @param params Input containing template name and optional culture name
+   * @returns Promise with template content
+   */
+  async dispatchGetTemplateContent(params) {
+    const result = await this.templateContentService.getByInput(params);
+    this._state.templateContent = result;
+    return result;
+  }
+  /**
+   * Dispatch action to update template content
+   * @param body DTO containing template name, culture name, and content
+   * @returns Promise with updated template content
+   */
+  async dispatchUpdateTemplateContent(body) {
+    const result = await this.templateContentService.updateByInput(body);
+    this._state.templateContent = result;
+    return result;
+  }
+  /**
+   * Dispatch action to restore template content to default
+   * @param body Input containing template name and culture name
+   * @returns Promise that resolves when restore is complete
+   */
+  async dispatchRestoreToDefault(body) {
+    await this.templateContentService.restoreToDefaultByInput(body);
+    if (body.cultureName) {
+      await this.dispatchGetTemplateContent(body);
+    }
+  }
+  /**
+   * Set the selected template
+   * @param template Template to select or null to clear
+   */
+  setSelectedTemplate(template) {
+    this._state.selectedTemplate = template;
+  }
+  /**
+   * Clear all state
+   */
+  reset() {
+    this._state = {
+      templateDefinitions: [],
+      totalCount: 0,
+      selectedTemplate: null,
+      templateContent: null
+    };
+  }
+};
+
+// src/hooks/useTextTemplates.ts
+import { useState, useCallback, useMemo } from "react";
+import { useRestService } from "@abpjs/core";
+function useTextTemplates() {
+  const restService = useRestService();
+  const templateDefinitionService = useMemo(
+    () => new TemplateDefinitionService(restService),
+    [restService]
+  );
+  const templateContentService = useMemo(
+    () => new TemplateContentService(restService),
+    [restService]
+  );
+  const [templateDefinitions, setTemplateDefinitions] = useState([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [selectedTemplate, setSelectedTemplate] = useState(null);
+  const [templateContent, setTemplateContent] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchTemplateDefinitions = useCallback(
+    async (params = {}) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await templateDefinitionService.getList(params);
+        const items = result.items || [];
+        setTemplateDefinitions(items);
+        setTotalCount(items.length);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to fetch template definitions";
+        setError(message);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [templateDefinitionService]
+  );
+  const getTemplateContent = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await templateContentService.getByInput(params);
+        setTemplateContent(result);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to fetch template content";
+        setError(message);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [templateContentService]
+  );
+  const updateTemplateContent = useCallback(
+    async (body) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await templateContentService.updateByInput(body);
+        setTemplateContent(result);
+        return { success: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to update template content";
+        setError(message);
+        return { success: false, error: message };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [templateContentService]
+  );
+  const restoreToDefault = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await templateContentService.restoreToDefaultByInput(params);
+        if (params.cultureName) {
+          const result = await templateContentService.getByInput(params);
+          setTemplateContent(result);
+        }
+        return { success: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to restore template to default";
+        setError(message);
+        return { success: false, error: message };
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [templateContentService]
+  );
+  const reset = useCallback(() => {
+    setTemplateDefinitions([]);
+    setTotalCount(0);
+    setSelectedTemplate(null);
+    setTemplateContent(null);
+    setError(null);
+  }, []);
+  return {
+    templateDefinitions,
+    totalCount,
+    selectedTemplate,
+    templateContent,
+    isLoading,
+    error,
+    fetchTemplateDefinitions,
+    getTemplateContent,
+    updateTemplateContent,
+    restoreToDefault,
+    setSelectedTemplate,
+    reset
+  };
+}
+
+// src/components/TextTemplatesComponent/TextTemplatesComponent.tsx
+import { useEffect, useState as useState2 } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function TextTemplatesComponent({
+  onEditContents,
+  className = "",
+  pageSize = 10
+}) {
+  const {
+    templateDefinitions,
+    isLoading,
+    error,
+    fetchTemplateDefinitions,
+    setSelectedTemplate
+  } = useTextTemplates();
+  const [currentPage, setCurrentPage] = useState2(1);
+  useEffect(() => {
+    fetchTemplateDefinitions({
+      skipCount: (currentPage - 1) * pageSize,
+      maxResultCount: pageSize
+    });
+  }, [fetchTemplateDefinitions, currentPage, pageSize]);
+  const handleEditContents = (template) => {
+    setSelectedTemplate(template);
+    onEditContents?.(template);
+  };
+  const handlePageChange = (page) => {
+    setCurrentPage(page);
+  };
+  if (error) {
+    return /* @__PURE__ */ jsxs("div", { className: `text-templates-error ${className}`, style: styles.error, children: [
+      /* @__PURE__ */ jsxs("p", { children: [
+        "Error loading templates: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => fetchTemplateDefinitions(),
+          style: styles.retryButton,
+          children: "Retry"
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: `text-templates-component ${className}`, style: styles.container, children: [
+    /* @__PURE__ */ jsx("div", { className: "text-templates-header", style: styles.header, children: /* @__PURE__ */ jsx("h2", { style: styles.title, children: "Text Templates" }) }),
+    isLoading ? /* @__PURE__ */ jsx("div", { style: styles.loading, children: "Loading..." }) : templateDefinitions.length === 0 ? /* @__PURE__ */ jsx("div", { style: styles.empty, children: "No text templates found." }) : /* @__PURE__ */ jsx("div", { style: styles.tableWrapper, children: /* @__PURE__ */ jsxs("table", { style: styles.table, children: [
+      /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Name" }),
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Display Name" }),
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Is Layout" }),
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Layout" }),
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Default Culture" }),
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Inline Localized" }),
+        /* @__PURE__ */ jsx("th", { style: styles.th, children: "Actions" })
+      ] }) }),
+      /* @__PURE__ */ jsx("tbody", { children: templateDefinitions.map((template) => /* @__PURE__ */ jsxs("tr", { style: styles.tr, children: [
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: template.name }),
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: template.displayName }),
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: template.isLayout ? "Yes" : "No" }),
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: template.layout || "-" }),
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: template.defaultCultureName || "-" }),
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: template.isInlineLocalized ? "Yes" : "No" }),
+        /* @__PURE__ */ jsx("td", { style: styles.td, children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => handleEditContents(template),
+            style: styles.actionButton,
+            children: "Edit Contents"
+          }
+        ) })
+      ] }, template.name)) })
+    ] }) }),
+    templateDefinitions.length > 0 && /* @__PURE__ */ jsxs("div", { style: styles.pagination, children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => handlePageChange(currentPage - 1),
+          disabled: currentPage === 1,
+          style: styles.pageButton,
+          children: "Previous"
+        }
+      ),
+      /* @__PURE__ */ jsxs("span", { style: styles.pageInfo, children: [
+        "Page ",
+        currentPage
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => handlePageChange(currentPage + 1),
+          disabled: templateDefinitions.length < pageSize,
+          style: styles.pageButton,
+          children: "Next"
+        }
+      )
+    ] })
+  ] });
+}
+var styles = {
+  container: {
+    padding: "16px"
+  },
+  header: {
+    display: "flex",
+    justifyContent: "space-between",
+    alignItems: "center",
+    marginBottom: "16px"
+  },
+  title: {
+    margin: 0,
+    fontSize: "24px",
+    fontWeight: 600
+  },
+  loading: {
+    padding: "32px",
+    textAlign: "center",
+    color: "#666"
+  },
+  empty: {
+    padding: "32px",
+    textAlign: "center",
+    color: "#666"
+  },
+  error: {
+    padding: "32px",
+    textAlign: "center",
+    color: "#dc2626"
+  },
+  retryButton: {
+    marginTop: "8px",
+    padding: "8px 16px",
+    border: "none",
+    borderRadius: "4px",
+    backgroundColor: "#3b82f6",
+    color: "white",
+    cursor: "pointer"
+  },
+  tableWrapper: {
+    overflowX: "auto"
+  },
+  table: {
+    width: "100%",
+    borderCollapse: "collapse",
+    fontSize: "14px"
+  },
+  th: {
+    padding: "12px 8px",
+    textAlign: "left",
+    borderBottom: "2px solid #e5e7eb",
+    fontWeight: 600,
+    color: "#374151"
+  },
+  tr: {
+    borderBottom: "1px solid #e5e7eb"
+  },
+  td: {
+    padding: "12px 8px",
+    color: "#4b5563"
+  },
+  actionButton: {
+    padding: "6px 12px",
+    border: "none",
+    borderRadius: "4px",
+    backgroundColor: "#3b82f6",
+    color: "white",
+    fontSize: "12px",
+    cursor: "pointer"
+  },
+  pagination: {
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center",
+    gap: "16px",
+    marginTop: "16px"
+  },
+  pageButton: {
+    padding: "8px 16px",
+    border: "1px solid #e5e7eb",
+    borderRadius: "4px",
+    backgroundColor: "white",
+    cursor: "pointer"
+  },
+  pageInfo: {
+    color: "#6b7280"
+  }
+};
+
+// src/components/TemplateContentsComponent/TemplateContentsComponent.tsx
+import { useEffect as useEffect2, useState as useState3, useCallback as useCallback2 } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function TemplateContentsComponent({
+  templateName,
+  cultures = [],
+  defaultCultureName,
+  onSave,
+  onRestore,
+  className = ""
+}) {
+  const {
+    templateContent,
+    isLoading,
+    error,
+    getTemplateContent,
+    updateTemplateContent,
+    restoreToDefault
+  } = useTextTemplates();
+  const [selectedCulture, setSelectedCulture] = useState3(defaultCultureName || "");
+  const [content, setContent] = useState3("");
+  const [referenceContent, setReferenceContent] = useState3("");
+  const [isSaving, setIsSaving] = useState3(false);
+  useEffect2(() => {
+    if (templateName && selectedCulture) {
+      getTemplateContent({
+        templateName,
+        cultureName: selectedCulture
+      });
+    }
+  }, [templateName, selectedCulture, getTemplateContent]);
+  useEffect2(() => {
+    if (templateName && defaultCultureName && defaultCultureName !== selectedCulture) {
+      setReferenceContent("Reference content would be loaded here");
+    }
+  }, [templateName, defaultCultureName, selectedCulture]);
+  useEffect2(() => {
+    if (templateContent) {
+      setContent(templateContent.content || "");
+    }
+  }, [templateContent]);
+  const handleCultureChange = useCallback2((e) => {
+    setSelectedCulture(e.target.value);
+  }, []);
+  const handleContentChange = useCallback2((e) => {
+    setContent(e.target.value);
+  }, []);
+  const handleSave = useCallback2(async () => {
+    if (!templateName || !selectedCulture) return;
+    setIsSaving(true);
+    const result = await updateTemplateContent({
+      templateName,
+      cultureName: selectedCulture,
+      content
+    });
+    setIsSaving(false);
+    if (result.success && templateContent) {
+      onSave?.(templateContent);
+    }
+  }, [templateName, selectedCulture, content, updateTemplateContent, templateContent, onSave]);
+  const handleRestoreToDefault = useCallback2(async () => {
+    if (!templateName || !selectedCulture) return;
+    const confirmed = window.confirm(
+      "Are you sure you want to restore this template to its default content?"
+    );
+    if (!confirmed) return;
+    setIsSaving(true);
+    const result = await restoreToDefault({
+      templateName,
+      cultureName: selectedCulture
+    });
+    setIsSaving(false);
+    if (result.success) {
+      onRestore?.();
+    }
+  }, [templateName, selectedCulture, restoreToDefault, onRestore]);
+  if (error) {
+    return /* @__PURE__ */ jsx2("div", { className: `template-contents-error ${className}`, style: styles2.error, children: /* @__PURE__ */ jsxs2("p", { children: [
+      "Error: ",
+      error
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs2("div", { className: `template-contents-component ${className}`, style: styles2.container, children: [
+    /* @__PURE__ */ jsx2("div", { style: styles2.header, children: /* @__PURE__ */ jsxs2("h2", { style: styles2.title, children: [
+      "Edit Template: ",
+      templateName
+    ] }) }),
+    /* @__PURE__ */ jsxs2("div", { style: styles2.cultureSelector, children: [
+      /* @__PURE__ */ jsx2("label", { htmlFor: "culture-select", style: styles2.label, children: "Culture:" }),
+      /* @__PURE__ */ jsxs2(
+        "select",
+        {
+          id: "culture-select",
+          value: selectedCulture,
+          onChange: handleCultureChange,
+          style: styles2.select,
+          children: [
+            /* @__PURE__ */ jsx2("option", { value: "", children: "Select a culture" }),
+            cultures.map((culture) => /* @__PURE__ */ jsx2("option", { value: culture.name, children: culture.displayName }, culture.name))
+          ]
+        }
+      )
+    ] }),
+    isLoading ? /* @__PURE__ */ jsx2("div", { style: styles2.loading, children: "Loading template content..." }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+      referenceContent && defaultCultureName !== selectedCulture && /* @__PURE__ */ jsxs2("div", { style: styles2.referenceSection, children: [
+        /* @__PURE__ */ jsxs2("h4", { style: styles2.sectionTitle, children: [
+          "Reference Content (",
+          defaultCultureName,
+          ")"
+        ] }),
+        /* @__PURE__ */ jsx2("pre", { style: styles2.referenceContent, children: referenceContent })
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { style: styles2.editorSection, children: [
+        /* @__PURE__ */ jsxs2("h4", { style: styles2.sectionTitle, children: [
+          "Content ",
+          selectedCulture ? `(${selectedCulture})` : ""
+        ] }),
+        /* @__PURE__ */ jsx2(
+          "textarea",
+          {
+            value: content,
+            onChange: handleContentChange,
+            style: styles2.textarea,
+            rows: 15,
+            placeholder: "Enter template content...",
+            disabled: !selectedCulture
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { style: styles2.actions, children: [
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            type: "button",
+            onClick: handleRestoreToDefault,
+            disabled: isSaving || !selectedCulture,
+            style: styles2.restoreButton,
+            children: "Restore to Default"
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            type: "button",
+            onClick: handleSave,
+            disabled: isSaving || !selectedCulture,
+            style: styles2.saveButton,
+            children: isSaving ? "Saving..." : "Save"
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+var styles2 = {
+  container: {
+    padding: "16px"
+  },
+  header: {
+    marginBottom: "16px"
+  },
+  title: {
+    margin: 0,
+    fontSize: "20px",
+    fontWeight: 600
+  },
+  cultureSelector: {
+    marginBottom: "16px",
+    display: "flex",
+    alignItems: "center",
+    gap: "8px"
+  },
+  label: {
+    fontWeight: 500,
+    color: "#374151"
+  },
+  select: {
+    padding: "8px 12px",
+    borderRadius: "4px",
+    border: "1px solid #d1d5db",
+    fontSize: "14px",
+    minWidth: "200px"
+  },
+  loading: {
+    padding: "32px",
+    textAlign: "center",
+    color: "#666"
+  },
+  error: {
+    padding: "32px",
+    textAlign: "center",
+    color: "#dc2626"
+  },
+  referenceSection: {
+    marginBottom: "16px",
+    padding: "12px",
+    backgroundColor: "#f9fafb",
+    borderRadius: "4px"
+  },
+  sectionTitle: {
+    margin: "0 0 8px 0",
+    fontSize: "14px",
+    fontWeight: 500,
+    color: "#6b7280"
+  },
+  referenceContent: {
+    margin: 0,
+    padding: "8px",
+    backgroundColor: "#f3f4f6",
+    borderRadius: "4px",
+    fontSize: "13px",
+    fontFamily: "monospace",
+    whiteSpace: "pre-wrap",
+    maxHeight: "200px",
+    overflow: "auto"
+  },
+  editorSection: {
+    marginBottom: "16px"
+  },
+  textarea: {
+    width: "100%",
+    padding: "12px",
+    borderRadius: "4px",
+    border: "1px solid #d1d5db",
+    fontSize: "14px",
+    fontFamily: "monospace",
+    resize: "vertical",
+    minHeight: "200px"
+  },
+  actions: {
+    display: "flex",
+    justifyContent: "flex-end",
+    gap: "8px"
+  },
+  restoreButton: {
+    padding: "10px 20px",
+    border: "1px solid #d1d5db",
+    borderRadius: "4px",
+    backgroundColor: "white",
+    color: "#374151",
+    fontSize: "14px",
+    cursor: "pointer"
+  },
+  saveButton: {
+    padding: "10px 20px",
+    border: "none",
+    borderRadius: "4px",
+    backgroundColor: "#3b82f6",
+    color: "white",
+    fontSize: "14px",
+    cursor: "pointer"
+  }
+};
+export {
+  TEXT_TEMPLATE_MANAGEMENT_ROUTES,
+  TemplateContentService,
+  TemplateContentsComponent,
+  TemplateDefinitionService,
+  TextTemplateManagementStateService,
+  TextTemplatesComponent,
+  eTextTemplateManagementComponents,
+  eTextTemplateManagementRouteNames,
+  useTextTemplates
+};