@okf/ootils 1.31.2 → 1.31.3

package/dist/node.js

@@ -3052,8 +3052,203 @@ var compareAndGroupBlocks = (blocksPerTpl) => {
   return Array.from(templateGroupToFilters.values());
 };
 
+// src/blockRegistry/schemaPresets.ts
+var MONGO_SCHEMA_PRESETS = {
+  object: { type: Object },
+  string: { type: String }
+};
+var ELASTIC_MAPPING_PRESETS = {
+  largeText: {
+    properties: {
+      allText: {
+        type: "text",
+        analyzer: "LargeTextAnalyzer"
+      }
+    }
+  }
+};
+var CHUNKING_PRESETS = {
+  // Lexical-shaped text — uses semantic chunking on allText
+  lexicalSemantic: {
+    strategy: "semanticChunking",
+    windowSize: 3,
+    minSimilarityScore: 0.7
+  },
+  // Plain text input — single chunk per field
+  simpleText: {
+    strategy: "simpleChunking"
+  }
+};
+
+// src/blockRegistry/blocks/LexicalTextEditor.ts
+var LexicalTextEditor = {
+  compName: "LexicalTextEditor",
+  // Identity
+  category: "text",
+  qualQuant: "qual",
+  // Schema
+  mongoSchemaType: MONGO_SCHEMA_PRESETS.object,
+  esMapping: ELASTIC_MAPPING_PRESETS.largeText,
+  // Capabilities
+  capabilities: {
+    hasPlainText: true,
+    annotation: true,
+    aiAnnotation: true,
+    aiEnrichment: true,
+    searchable: true,
+    directDataImport: true,
+    csvExport: true,
+    translatable: true,
+    documentSummarizer: true,
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
+  },
+  // Field paths
+  fieldPaths: {
+    plainTextString: "allText",
+    searchField: "allText",
+    displayValue: "allText"
+  },
+  // Validation
+  validation: {
+    populatedCheckFn: "lexicalTextEditorHasValue",
+    formValidationFn: "lexicalTextEditorHasValue"
+  },
+  // Translation
+  translation: {
+    handlerType: "LexicalBlockHandler"
+  },
+  // Table rendering
+  tableCell: {
+    cellComp: "RichTextAsPlainTextLex",
+    sortPathSuffix: "editorState.root.children.0.children.0.text"
+  },
+  // CSV export
+  csvExport: {
+    transformFn: "KPRichLexicalEditor"
+  },
+  // Slack
+  slackFormat: {
+    handlerFn: "lexicalRichText"
+  },
+  // Batch import
+  batchImport: {
+    valueInjectorFn: "toLexicalValue"
+  },
+  // Content block option — TCI template builder & direct import UI
+  contentBlockOption: {
+    display: "Rich Text Field",
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
+  },
+  // Chunking config — used by okf-sub CreateChunksHandler
+  chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
+};
+
+// src/blockRegistry/registry.ts
+var BlockRegistry = class {
+  constructor() {
+    this.blocks = /* @__PURE__ */ new Map();
+    this.register(LexicalTextEditor);
+  }
+  /** Register a block descriptor. */
+  register(descriptor) {
+    this.blocks.set(descriptor.compName, descriptor);
+  }
+  /** Get the full descriptor for a block type. Returns undefined if not registered. */
+  getBlock(compType) {
+    return this.blocks.get(compType);
+  }
+  /** Check if a block type is registered in the registry. */
+  isRegistered(compType) {
+    return this.blocks.has(compType);
+  }
+  /**
+   * Get all registered block descriptors that have a given capability set to a truthy value.
+   * Optionally pass a specific value to match (e.g. for enum-style capabilities).
+   */
+  getBlocksByCapability(capability, value = true) {
+    return Array.from(this.blocks.values()).filter((b) => {
+      const cap = b.capabilities[capability];
+      if (value === true) return !!cap;
+      return cap === value;
+    });
+  }
+  /**
+   * Get compType strings for all registered blocks with a given capability.
+   * Replaces scattered hardcoded arrays like:
+   *   const TEXT_FIELD_COMPONENTS = ["TextInput", "LexicalTextEditor", ...]
+   * becomes:
+   *   const TEXT_FIELD_COMPONENTS = blockRegistry.getComps('aiTextExtraction')
+   */
+  getComps(capability, value = true) {
+    return this.getBlocksByCapability(capability, value).map((b) => b.compName);
+  }
+  /** Get all registered blocks in a given category. */
+  getBlocksByCategory(category) {
+    return Array.from(this.blocks.values()).filter((b) => b.category === category);
+  }
+  /** Get compType strings for all qual blocks. */
+  getQualBlocks() {
+    return Array.from(this.blocks.values()).filter((b) => b.qualQuant === "qual").map((b) => b.compName);
+  }
+  /** Get compType strings for all quant blocks. */
+  getQuantBlocks() {
+    return Array.from(this.blocks.values()).filter((b) => b.qualQuant === "quant").map((b) => b.compName);
+  }
+  /** Check if a specific block has a specific capability. */
+  hasCapability(compType, capability) {
+    const block = this.blocks.get(compType);
+    if (!block) return false;
+    return !!block.capabilities[capability];
+  }
+  /** Get all registered block descriptors. */
+  getAll() {
+    return Array.from(this.blocks.values());
+  }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
+  /**
+   * Resolve the tagTypesConfig for a block instance.
+   *
+   * Resolution order:
+   * 1. `hardCodedTagTypesConfigForSM` — the intended self-managed default, which takes
+   *    priority over per-instance values (justifies not persisting per-block on self-managed).
+   *    Sourced from `GET_SELF_MANAGED_BASE_CONFIGS().annotation_tagTypesConfig` on BE,
+   *    or `platformConfigs.SELF_MANAGED_BASE_CONFIGS.annotation_tagTypesConfig` on FE.
+   *    Pass null/undefined for non-SM tenants.
+   * 2. `block.props.annotation.tagTypesConfig` — legacy per-instance persisted value.
+   * 3. Empty array.
+   */
+  getTagTypesConfig(block, hardCodedTagTypesConfigForSM) {
+    return hardCodedTagTypesConfigForSM || block.props?.annotation?.tagTypesConfig || [];
+  }
+};
+var blockRegistry = new BlockRegistry();
+
 // src/utils/autoGenFilterConfigsFromTpl/utils/extractAndOrganizeBlocks.ts
-var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
+var extractAndOrganizeBlocks = (selectedTpls, allTpls, { smTagTypesConfig } = {}) => {
   const extractedBlocks = {};
   const templateBlocksCache = /* @__PURE__ */ new Map();
   const getCachedBlocks = (tpl) => {
@@ -3064,7 +3259,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
   };
   extractedBlocks.annoTagBlocks = selectedTpls.map((tpl) => {
     const allBlocks = getCachedBlocks(tpl);
-    const allTagTypes = allBlocks.filter((block) => block.props?.annotation?.enable).flatMap((block) => block.props.annotation.tagTypesConfig?.map((d) => d.tagType) || []);
+    const allTagTypes = blockRegistry.getAnnotationEnabledBlocks(allBlocks).flatMap((block) => blockRegistry.getTagTypesConfig(block, smTagTypesConfig).map((d) => d.tagType));
     const uniqueTagTypes = [...new Set(allTagTypes)];
     return {
       contentType: tpl.kp_content_type,
@@ -3078,13 +3273,13 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls) => {
     const allBlocks = getCachedBlocks(tpl);
     return {
       contentType: tpl.kp_content_type,
-      blocks: allBlocks.filter((block) => block.props?.annotation?.enable)
+      blocks: blockRegistry.getAnnotationEnabledBlocks(allBlocks)
     };
   });
   extractedBlocks.annoRollupBlocks = selectedTpls.map((tpl) => {
     const allBlocks = getCachedBlocks(tpl);
     const uniqueTagTypes = Array.from(new Set(
-      allBlocks.filter((block) => block.props?.annotation?.enable).flatMap((block) => block.props.annotation.tagTypesConfig || []).map((conf) => conf.tagType)
+      blockRegistry.getAnnotationEnabledBlocks(allBlocks).flatMap((block) => blockRegistry.getTagTypesConfig(block, smTagTypesConfig)).map((conf) => conf.tagType)
     ));
     return {
       contentType: tpl.kp_content_type,
@@ -3731,9 +3926,10 @@ var autoGenFilterConfigsFromTpl = ({
   allTpls,
   filterScopes,
   isSelfManagedTenant = false,
-  annotationTagsCount
+  annotationTagsCount,
+  smTagTypesConfig
 }) => {
-  const extractedBlocks = extractAndOrganizeBlocks(selectedTpls, allTpls);
+  const extractedBlocks = extractAndOrganizeBlocks(selectedTpls, allTpls, { smTagTypesConfig });
   const allAnnoEnabledBlocks = filterScopes.includes("anno") ? extractedBlocks.annoEnabledBlocks.flatMap((item) => item.blocks).reduce((acc, block) => {
     if (!acc.find((b) => b.valuePath === block.valuePath)) {
       acc.push(block);
@@ -3855,186 +4051,6 @@ var genCleanCamelCaseId = (id) => {
   return result.slice(0, MAX_LENGTH);
 };
 
-// src/blockRegistry/schemaPresets.ts
-var MONGO_SCHEMA_PRESETS = {
-  object: { type: Object },
-  string: { type: String }
-};
-var ELASTIC_MAPPING_PRESETS = {
-  largeText: {
-    properties: {
-      allText: {
-        type: "text",
-        analyzer: "LargeTextAnalyzer"
-      }
-    }
-  }
-};
-var CHUNKING_PRESETS = {
-  // Lexical-shaped text — uses semantic chunking on allText
-  lexicalSemantic: {
-    strategy: "semanticChunking",
-    windowSize: 3,
-    minSimilarityScore: 0.7
-  },
-  // Plain text input — single chunk per field
-  simpleText: {
-    strategy: "simpleChunking"
-  }
-};
-
-// src/blockRegistry/blocks/LexicalTextEditor.ts
-var LexicalTextEditor = {
-  compName: "LexicalTextEditor",
-  // Identity
-  category: "text",
-  qualQuant: "qual",
-  // Schema
-  mongoSchemaType: MONGO_SCHEMA_PRESETS.object,
-  esMapping: ELASTIC_MAPPING_PRESETS.largeText,
-  // Capabilities
-  capabilities: {
-    hasPlainText: true,
-    annotation: true,
-    aiAnnotation: true,
-    aiEnrichment: true,
-    searchable: true,
-    directDataImport: true,
-    csvExport: true,
-    translatable: true,
-    documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true,
-    excludeFromListingProjection: true
-  },
-  // Field paths
-  fieldPaths: {
-    plainTextString: "allText",
-    searchField: "allText",
-    displayValue: "allText"
-  },
-  // Validation
-  validation: {
-    populatedCheckFn: "lexicalTextEditorHasValue",
-    formValidationFn: "lexicalTextEditorHasValue"
-  },
-  // Translation
-  translation: {
-    handlerType: "LexicalBlockHandler"
-  },
-  // Table rendering
-  tableCell: {
-    cellComp: "RichTextAsPlainTextLex",
-    sortPathSuffix: "editorState.root.children.0.children.0.text"
-  },
-  // CSV export
-  csvExport: {
-    transformFn: "KPRichLexicalEditor"
-  },
-  // Slack
-  slackFormat: {
-    handlerFn: "lexicalRichText"
-  },
-  // Batch import
-  batchImport: {
-    valueInjectorFn: "toLexicalValue"
-  },
-  // Content block option — TCI template builder & direct import UI
-  contentBlockOption: {
-    display: "Rich Text Field",
-    icon: "TextAa",
-    directImportGroupsIdx: [2, 2]
-  },
-  // Chunking config — used by okf-sub CreateChunksHandler
-  chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
-};
-
-// src/blockRegistry/registry.ts
-var BlockRegistry = class {
-  constructor() {
-    this.blocks = /* @__PURE__ */ new Map();
-    this.register(LexicalTextEditor);
-  }
-  /** Register a block descriptor. */
-  register(descriptor) {
-    this.blocks.set(descriptor.compName, descriptor);
-  }
-  /** Get the full descriptor for a block type. Returns undefined if not registered. */
-  getBlock(compType) {
-    return this.blocks.get(compType);
-  }
-  /** Check if a block type is registered in the registry. */
-  isRegistered(compType) {
-    return this.blocks.has(compType);
-  }
-  /**
-   * Get all registered block descriptors that have a given capability set to a truthy value.
-   * Optionally pass a specific value to match (e.g. for enum-style capabilities).
-   */
-  getBlocksByCapability(capability, value = true) {
-    return Array.from(this.blocks.values()).filter((b) => {
-      const cap = b.capabilities[capability];
-      if (value === true) return !!cap;
-      return cap === value;
-    });
-  }
-  /**
-   * Get compType strings for all registered blocks with a given capability.
-   * Replaces scattered hardcoded arrays like:
-   *   const TEXT_FIELD_COMPONENTS = ["TextInput", "LexicalTextEditor", ...]
-   * becomes:
-   *   const TEXT_FIELD_COMPONENTS = blockRegistry.getComps('aiTextExtraction')
-   */
-  getComps(capability, value = true) {
-    return this.getBlocksByCapability(capability, value).map((b) => b.compName);
-  }
-  /** Get all registered blocks in a given category. */
-  getBlocksByCategory(category) {
-    return Array.from(this.blocks.values()).filter((b) => b.category === category);
-  }
-  /** Get compType strings for all qual blocks. */
-  getQualBlocks() {
-    return Array.from(this.blocks.values()).filter((b) => b.qualQuant === "qual").map((b) => b.compName);
-  }
-  /** Get compType strings for all quant blocks. */
-  getQuantBlocks() {
-    return Array.from(this.blocks.values()).filter((b) => b.qualQuant === "quant").map((b) => b.compName);
-  }
-  /** Check if a specific block has a specific capability. */
-  hasCapability(compType, capability) {
-    const block = this.blocks.get(compType);
-    if (!block) return false;
-    return !!block.capabilities[capability];
-  }
-  /** Get all registered block descriptors. */
-  getAll() {
-    return Array.from(this.blocks.values());
-  }
-  /**
-   * Get compName strings for all registered blocks that have a chunking config.
-   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
-   * description) to know which fields actually have chunks to search.
-   */
-  getCompsWithChunking() {
-    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
-  }
-  /**
-   * Filter a list of block instances down to those where annotation is enabled.
-   * A block is annotation-enabled if its registry capability `annotation` is true.
-   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
-   * falls back to the legacy per-instance `props.annotation.enable` toggle.
-   *
-   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
-   */
-  getAnnotationEnabledBlocks(allBlocks) {
-    return allBlocks.filter((block) => {
-      const blockDef = this.blocks.get(block.comp);
-      if (blockDef) return !!blockDef.capabilities.annotation;
-      return block.props?.annotation?.enable === true;
-    });
-  }
-};
-var blockRegistry = new BlockRegistry();
-
 // src/node.ts
 var import_MongoConnector3 = __toESM(require_MongoConnector());
 var import_ElasticSearchConnector = __toESM(require_ElasticSearchConnector());