@okf/ootils 1.31.5 → 1.32.0

package/dist/universal.mjs

@@ -312,7 +312,8 @@ var _extractBlocksFromSomeBuilders = ({
 // src/blockRegistry/schemaPresets.ts
 var MONGO_SCHEMA_PRESETS = {
   object: { type: Object },
-  string: { type: String }
+  string: { type: String },
+  array: { type: Array }
 };
 var ELASTIC_MAPPING_PRESETS = {
   largeText: {
@@ -322,6 +323,24 @@ var ELASTIC_MAPPING_PRESETS = {
         analyzer: "LargeTextAnalyzer"
       }
     }
+  },
+  // Audio file value (array of one object) — only the transcription.result.finalText
+  // is indexed as searchable text. Everything else on the audio object is ignored.
+  audioTranscription: {
+    properties: {
+      transcription: {
+        properties: {
+          result: {
+            properties: {
+              finalText: {
+                type: "text",
+                analyzer: "LargeTextAnalyzer"
+              }
+            }
+          }
+        }
+      }
+    }
   }
 };
 var CHUNKING_PRESETS = {
@@ -363,8 +382,7 @@ var LexicalTextEditor = {
   // Field paths
   fieldPaths: {
     plainTextString: "allText",
-    searchField: "allText",
-    displayValue: "allText"
+    searchField: "allText"
   },
   // Validation
   validation: {
@@ -402,11 +420,72 @@ var LexicalTextEditor = {
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
 };
 
+// src/blockRegistry/blocks/AudioInput.ts
+var AudioInput = {
+  compName: "AudioInput",
+  // Identity
+  category: "media",
+  qualQuant: "qual",
+  // Only qualitative when the tpl block has transcription turned on.
+  // A non-transcribed audio input has no text to analyze, so downstream
+  // qual widgets / search tools should skip it.
+  qualConditions: [
+    { propPath: "transcription.enable", equals: true }
+  ],
+  // Schema
+  mongoSchemaType: MONGO_SCHEMA_PRESETS.array,
+  esMapping: ELASTIC_MAPPING_PRESETS.audioTranscription,
+  // Capabilities
+  capabilities: {
+    // Text lives at transcription.result.finalText on the first (and only) audio item,
+    // derived by the Sarvam adapter into a single canonical field.
+    hasPlainText: true,
+    annotation: true,
+    aiAnnotation: true,
+    aiEnrichment: true,
+    searchable: true,
+    directDataImport: false,
+    csvExport: true,
+    // Translation already happens at the Sarvam level via translateToEnglish flag,
+    // so the autoTranslate pipeline doesn't need to touch this block.
+    translatable: false,
+    documentSummarizer: true,
+    // Transcription payloads can be large — strip from chunk/anno main snapshots
+    // and listing projections.
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
+  },
+  // Field paths
+  // `plainTextString` is the Mongo path consumed by getVal (supports the leading
+  // array index). `searchField` is the ES path — ES flattens arrays of objects
+  // so no index is needed there.
+  fieldPaths: {
+    plainTextString: "0.transcription.result.finalText",
+    searchField: "transcription.result.finalText"
+  },
+  // Validation
+  validation: {
+    populatedCheckFn: "valueArrayIsNotEmpty"
+  },
+  // CSV export — existing transformStructureComp switch routes AudioInput to
+  // formatMediaLinks (outputs audio URLs).
+  csvExport: {
+    transformFn: "formatMediaLinks"
+  },
+  // Chunking — finalText is long free-form speech, so semantic chunking applies.
+  chunkingConfig: CHUNKING_PRESETS.lexicalSemantic,
+  // Content block option — matches the current static entry exactly
+  contentBlockOption: {
+    display: "Audio Input"
+  }
+};
+
 // src/blockRegistry/registry.ts
 var BlockRegistry = class {
   constructor() {
     this.blocks = /* @__PURE__ */ new Map();
     this.register(LexicalTextEditor);
+    this.register(AudioInput);
   }
   /** Register a block descriptor. */
   register(descriptor) {
@@ -453,12 +532,36 @@ var BlockRegistry = class {
   getQuantBlocks() {
     return Array.from(this.blocks.values()).filter((b) => b.qualQuant === "quant").map((b) => b.compName);
   }
+  /**
+   * Returns true if a specific block instance should be treated as qualitative.
+   * Combines the static `qualQuant` flag with any per-instance `qualConditions`
+   * — e.g. AudioInput is only qual when `props.transcription.enable === true`.
+   */
+  isQualBlock(block) {
+    const def = this.blocks.get(block.comp);
+    if (!def || def.qualQuant !== "qual") return false;
+    if (!def.qualConditions?.length) return true;
+    return def.qualConditions.every((cond) => {
+      const value = cond.propPath.split(".").reduce((obj, key) => obj?.[key], block.props);
+      return value === cond.equals;
+    });
+  }
   /** 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];
   }
+  /**
+   * Returns true if the block stores its value as an array (Mongo schema type is Array).
+   * Useful for callers that need to know whether to query `valuePath.0` for existence
+   * vs just `valuePath` — empty arrays still pass `$exists: true` on the field itself.
+   * Returns false for unregistered blocks.
+   */
+  isArrayShaped(compType) {
+    const def = this.blocks.get(compType);
+    return def?.mongoSchemaType?.type === Array;
+  }
   /** Get all registered block descriptors. */
   getAll() {
     return Array.from(this.blocks.values());

package/package.json

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