@okf/ootils 1.26.4 → 1.28.0

package/dist/universal.mjs

@@ -1014,6 +1014,7 @@ var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup
             filterKey,
             contentType: element.contentType,
             path: element.valuePath,
+            ...element.comp && { comp: element.comp },
             source: {
               filterType: "tplType",
               contentType: element.contentType,
@@ -1039,6 +1040,7 @@ var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup
           filterKey: valuePathFilterKey,
           contentType: element.contentType,
           path: element.valuePath,
+          ...element.comp && { comp: element.comp },
           source: {
             filterType: "tplType",
             contentType: element.contentType,
@@ -1064,6 +1066,7 @@ var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup
           filterKey: dateFilterKey,
           contentType: element.contentType,
           path: element.valuePath,
+          ...element.comp && { comp: element.comp },
           source: { filterType: "dateRangeType" },
           target: { filterType: "dateRangeType", valuePath: element.valuePath }
         };
@@ -1081,6 +1084,7 @@ var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup
           filterKey: numberFilterKey,
           contentType: element.contentType,
           path: element.valuePath,
+          ...element.comp && { comp: element.comp },
           source: { filterType: "numberRangeType", valuePath: element.valuePath },
           target: { filterType: "numberRangeType", valuePath: element.valuePath }
         };
@@ -1201,6 +1205,7 @@ var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup
           filterKey: tagFilterKey,
           contentType: element.tagType,
           path: `tags.${element.tagType}`,
+          ...element.comp && { comp: element.comp },
           source: allProfileTpls.some(
             (tpl) => tpl.kp_content_type === element.tagType
           ) ? {
@@ -1342,6 +1347,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
       contentType: tpl.kp_content_type,
       blocks: allBlocks.filter((block) => block.valuePath.startsWith("tags.")).map((block) => ({
         tagType: block.props.tagType,
+        comp: block.comp,
         filterType: "tagType"
       }))
     };
@@ -1369,6 +1375,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
         value: block.valuePath,
         saveValueAsString: block.props?.saveValueAsString,
         contentType: tpl.kp_content_type,
+        comp: block.comp,
         filterType: "valuePathType"
       }))
     };
@@ -1383,6 +1390,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
         value: block.valuePath,
         saveValueAsString: block.props?.saveValueAsString,
         contentType: tpl.kp_content_type,
+        comp: block.comp,
         block,
         filterType: "split_valuePathType"
       }))
@@ -1397,6 +1405,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
         display: block.props?.shortLabel || block.props?.label || block.valuePath,
         value: block.valuePath,
         contentType: tpl.kp_content_type,
+        comp: block.comp,
         filterType: "dateRangeType"
       }))
     };
@@ -1410,6 +1419,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
         display: block.props?.shortLabel || block.props?.label || block.valuePath,
         value: block.valuePath,
         contentType: tpl.kp_content_type,
+        comp: block.comp,
         filterType: "numberRangeType"
       }))
     };
@@ -1656,6 +1666,240 @@ var _self_managed_buildAnnoHierarchyConfig = ({
   };
 };
 
+// src/utils/autoGenFilterConfigsFromTpl/utils/buildTagTypeParentMap.ts
+var buildTagTypeParentMap = (tagTypesInGroup, allTpls) => {
+  const tagTypeSet = new Set(tagTypesInGroup);
+  const parentMap = /* @__PURE__ */ new Map();
+  for (const tagType of tagTypesInGroup) {
+    const tpl = allTpls.find((t) => t.kp_content_type === tagType);
+    if (!tpl) continue;
+    const blocks = extractAllBlocksFromTpl({ tpl });
+    const tagBlocks = blocks.filter(
+      (block) => block.valuePath?.startsWith("tags.") && block.props?.tagType
+    );
+    for (const block of tagBlocks) {
+      const referencedTagType = block.props.tagType;
+      if (tagTypeSet.has(referencedTagType) && referencedTagType !== tagType) {
+        parentMap.set(tagType, referencedTagType);
+        break;
+      }
+    }
+  }
+  for (const child of parentMap.keys()) {
+    const visited = /* @__PURE__ */ new Set();
+    let current = child;
+    while (current && parentMap.has(current)) {
+      if (visited.has(current)) {
+        parentMap.delete(current);
+        break;
+      }
+      visited.add(current);
+      current = parentMap.get(current);
+    }
+  }
+  return parentMap;
+};
+var attachParentFields = (filters, allTpls) => {
+  const tagTypeFilters = filters.filter(
+    (f) => f.source?.filterType === "tagType" && f.source?.tagType
+  );
+  if (tagTypeFilters.length === 0) return filters;
+  const tagTypesInGroup = tagTypeFilters.map((f) => f.source.tagType);
+  const parentMap = buildTagTypeParentMap(tagTypesInGroup, allTpls);
+  if (parentMap.size === 0) return filters;
+  const tagTypeToFilterId = /* @__PURE__ */ new Map();
+  for (const f of tagTypeFilters) {
+    tagTypeToFilterId.set(f.source.tagType, f.filterId);
+  }
+  return filters.map((f) => {
+    if (f.source?.filterType !== "tagType" || !f.source?.tagType) return f;
+    const parentTagType = parentMap.get(f.source.tagType);
+    if (!parentTagType) return f;
+    const parentFilterId = tagTypeToFilterId.get(parentTagType);
+    if (!parentFilterId) return f;
+    return { ...f, parentFilterId };
+  });
+};
+var sortFiltersHierarchically = (filters) => {
+  if (filters.length <= 1) return filters;
+  const hasHierarchy = filters.some((f) => f.parentFilterId);
+  if (!hasHierarchy) return filters;
+  const childrenOf = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const f of filters) {
+    if (!f.parentFilterId) {
+      roots.push(f);
+    } else {
+      const siblings = childrenOf.get(f.parentFilterId) || [];
+      siblings.push(f);
+      childrenOf.set(f.parentFilterId, siblings);
+    }
+  }
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (filter) => {
+    if (visited.has(filter.filterId)) return;
+    visited.add(filter.filterId);
+    sorted.push(filter);
+    const children = childrenOf.get(filter.filterId) || [];
+    for (const child of children) {
+      visit(child);
+    }
+  };
+  for (const root of roots) {
+    visit(root);
+  }
+  for (const f of filters) {
+    if (!visited.has(f.filterId)) {
+      sorted.push(f);
+    }
+  }
+  return sorted;
+};
+
+// src/utils/autoGenFilterConfigsFromTpl/utils/_self_managed_buildDocHierarchyConfig.ts
+var _self_managed_buildDocHierarchyConfig = ({
+  combinedDocumentBlocks,
+  docRollupBlocks,
+  selectedTpls,
+  allTpls,
+  commonDocumentFilters,
+  flatDocFilters = false
+}) => {
+  const allGroups = compareAndGroupBlocks(combinedDocumentBlocks);
+  const commonGroup = allGroups.find(
+    (g) => g.contentTypes.length === selectedTpls.length
+  );
+  const commonFilterConfigs = commonGroup ? sortFiltersHierarchically(
+    attachParentFields(
+      buildFilterConfigurations({
+        groups: [commonGroup],
+        type: "tags",
+        selectedTpls,
+        allTpls,
+        isRollup: false,
+        isAnno: false
+      }).flatMap((s) => s.configs),
+      allTpls
+    )
+  ) : [];
+  const multiDatasetGroups = selectedTpls.length >= 2 ? allGroups.filter(
+    (g) => g.contentTypes.length > 1 && g.contentTypes.length < selectedTpls.length
+  ) : [];
+  const sharedAcrossMultiple = multiDatasetGroups.map((group) => {
+    const groupFilterConfigs = sortFiltersHierarchically(
+      attachParentFields(
+        buildFilterConfigurations({
+          groups: [group],
+          type: "tags",
+          selectedTpls,
+          allTpls,
+          isRollup: false,
+          isAnno: false
+        }).flatMap((s) => s.configs),
+        allTpls
+      )
+    );
+    const display = group.contentTypes.map((ct) => {
+      const tplData = allTpls.find(
+        (t) => t.kp_content_type === ct
+      );
+      return tplData?.general?.content?.title || ct;
+    }).join(" + ");
+    return {
+      contentTypes: group.contentTypes,
+      display,
+      filters: groupFilterConfigs
+    };
+  }).filter((g) => g.filters.length > 0);
+  const commonFilterIds = new Set(commonFilterConfigs.map((f) => f.filterId));
+  const perDataset = selectedTpls.map((tpl) => {
+    const tplBlocks = combinedDocumentBlocks.find(
+      (b) => b.contentType === tpl.kp_content_type
+    );
+    const singleTplGroup = [
+      {
+        contentTypes: [tpl.kp_content_type],
+        elements: tplBlocks?.blocks || []
+      }
+    ];
+    const filters = buildFilterConfigurations({
+      groups: singleTplGroup,
+      type: "tags",
+      selectedTpls: [tpl],
+      allTpls,
+      isRollup: false,
+      isAnno: false
+    }).flatMap((s) => s.configs);
+    const filtersWithCommonFlag = filters.map((f) => ({
+      ...f,
+      isSharedFilter: commonFilterIds.has(f.filterId)
+    }));
+    const rollupData = docRollupBlocks?.find(
+      (b) => b.contentType === tpl.kp_content_type
+    );
+    const rollupGroups = rollupData?.blocks?.length ? compareAndGroupBlocks([rollupData]) : [];
+    const rollupConfigs = rollupGroups.length ? buildFilterConfigurations({
+      groups: rollupGroups,
+      type: "tags",
+      selectedTpls: [tpl],
+      allTpls,
+      isRollup: true,
+      isAnno: false
+    }).flatMap((s) => s.configs) : [];
+    const tplData = allTpls.find(
+      (t) => t.kp_content_type === tpl.kp_content_type
+    );
+    const rollupSourceKeys = new Set(
+      rollupConfigs.map((r) => JSON.stringify(r.source))
+    );
+    const dedupedFilters = filtersWithCommonFlag.filter(
+      (f) => !rollupSourceKeys.has(JSON.stringify(f.source))
+    );
+    const combined = [...dedupedFilters, ...rollupConfigs];
+    const combinedWithParents = sortFiltersHierarchically(
+      attachParentFields(combined, allTpls)
+    );
+    const rollupFilterIds = new Set(rollupConfigs.map((r) => r.filterId));
+    const filtersWithParents = combinedWithParents.filter(
+      (f) => !rollupFilterIds.has(f.filterId)
+    );
+    const rollupsWithParents = combinedWithParents.filter(
+      (f) => rollupFilterIds.has(f.filterId)
+    );
+    return {
+      contentType: tpl.kp_content_type,
+      display: tplData?.general?.content?.title || tpl.kp_content_type,
+      filters: filtersWithParents,
+      rollups: rollupsWithParents
+    };
+  });
+  const filteredPerDataset = perDataset.filter(
+    (d) => d.filters.length > 0 || d.rollups.length > 0
+  );
+  if (commonFilterConfigs.length === 0 && sharedAcrossMultiple.length === 0 && filteredPerDataset.every((d) => d.filters.length === 0)) {
+    return null;
+  }
+  const flatCommonDocFilters = commonDocumentFilters.flatMap(
+    (s) => s.configs || [s]
+  );
+  const shouldFlatten = flatDocFilters && selectedTpls.length === 1;
+  return {
+    filterId: "docHierarchy_document_filters",
+    display: "Combined Content Filters",
+    filterKey: "docHierarchyType::doc",
+    source: {
+      filterType: "docHierarchyType",
+      flatDocFilters: shouldFlatten,
+      commonFilters: commonFilterConfigs,
+      sharedAcrossMultiple,
+      commonDocumentFilters: flatCommonDocFilters,
+      perDataset: filteredPerDataset
+    },
+    target: { filterType: "docHierarchyType" }
+  };
+};
+
 // src/utils/autoGenFilterConfigsFromTpl/utils/TEMP_removeDuplicateFilters.ts
 var TEMP_removeDuplicateFilters = (filterGroups) => {
   return filterGroups.map((group) => {
@@ -1792,7 +2036,25 @@ var autoGenFilterConfigsFromTpl = ({
       ...annotationRollupSections
     ].filter((section) => Array.isArray(section.configs) ? section.configs.length > 0 : true)
   };
-  const final_documentTagsFilterConfigs = {
+  const isSMTDocFilterUI = isSelfManagedTenant && filterScopes.includes("doc");
+  const final_documentTagsFilterConfigs = isSMTDocFilterUI ? (() => {
+    const docHierarchyConfig = _self_managed_buildDocHierarchyConfig({
+      combinedDocumentBlocks: extractedBlocks.combinedDocumentBlocks,
+      docRollupBlocks: extractedBlocks.docRollupBlocks,
+      selectedTpls,
+      allTpls,
+      commonDocumentFilters
+    });
+    if (!docHierarchyConfig) return { sectionId: "documentTagsSection", sectionTitle: "Document Filters", configs: [] };
+    return {
+      sectionId: "documentTagsSection",
+      // sectionTitle: 'Document Filters',
+      configs: [{
+        sectionId: "self_managed_consolidated_doc_filters",
+        configs: [docHierarchyConfig]
+      }]
+    };
+  })() : {
     sectionId: "documentTagsSection",
     sectionTitle: "Document Filters",
     configs: [
@@ -1806,12 +2068,47 @@ var autoGenFilterConfigsFromTpl = ({
   ].filter(Boolean);
   return result;
 };
+
+// src/utils/genCleanCamelCaseId.ts
+var genCleanCamelCaseId = (id) => {
+  if (!id || typeof id !== "string") return id;
+  const isAlreadyClean = /^\p{Ll}[\p{L}\p{N}]*$/u.test(id) || /^a\d[\p{L}\p{N}]*$/u.test(id);
+  if (isAlreadyClean) return id;
+  const words = id.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  if (words.length === 0) return "a";
+  const result = words.map((word, i) => {
+    const lower = word.toLowerCase();
+    return i === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+  return /^\d/.test(result) ? "a" + result : result;
+};
+
+// src/utils/genCleanIdForContentTypeAndValuePaths.ts
+var CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+function genShortId(length = 4) {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += CHARS[Math.floor(Math.random() * CHARS.length)];
+  }
+  return result;
+}
+var genCleanIdForContentTypeAndValuePaths = (text, maxLength = 10, shortIdLength = 4) => {
+  if (!text || typeof text !== "string") return text;
+  let cleaned = text.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+  if (!cleaned) {
+    throw new Error(`[genCleanIdForContentTypeAndValuePaths] Input "${text}" contains no alphanumeric characters`);
+  }
+  if (/^\d/.test(cleaned)) cleaned = "a" + cleaned;
+  const truncated = cleaned.slice(0, maxLength);
+  return `${truncated}_${genShortId(shortIdLength)}`;
+};
 export {
   BASE_BULLMQ_CONFIG,
   FILTER_IDS,
   TEMP_removeDuplicateFilters,
   UI_CONTENT,
   _self_managed_buildAnnoHierarchyConfig,
+  _self_managed_buildDocHierarchyConfig,
   _self_managed_getFixedAnnoRollupBlocks,
   _self_managed_getFixedAnnoTagBlock,
   autoGenFilterConfigsFromTpl,
@@ -1820,6 +2117,8 @@ export {
   deleteVal,
   extractAllBlocksFromTpl,
   extractAndOrganizeBlocks,
+  genCleanCamelCaseId,
+  genCleanIdForContentTypeAndValuePaths,
   genTagId,
   generateFilterKey,
   getFilterKeyForBlock,

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.26.4",
+  "version": "1.28.0",
   "description": "Utility functions for both browser and Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",