@okf/ootils 1.31.5 → 1.32.0

package/dist/browser.d.mts

@@ -1429,6 +1429,18 @@ interface BlockDef {
     compName: string;
     category: 'text' | 'selection' | 'tags' | 'date' | 'number' | 'media' | 'structural' | 'special';
     qualQuant: 'qual' | 'quant' | null;
+    /**
+     * Optional gate that downgrades a block instance from its declared qualQuant unless
+     * ALL conditions match. Used for blocks whose qual-ness depends on a per-instance prop
+     * (e.g. AudioInput is only qual when `props.transcription.enable === true`).
+     *
+     * Each condition is a dotted path into `block.props` with a required value.
+     * No conditions / undefined → block's qualQuant applies unconditionally.
+     */
+    qualConditions?: Array<{
+        propPath: string;
+        equals: any;
+    }>;
     /** Mongoose schema type — the actual value returned to compToTypeMap (e.g. { type: Object }) */
     mongoSchemaType: Record<string, any>;
     /** Elasticsearch mapping shape — used directly by generateMappingsFromTpl */
@@ -1440,8 +1452,6 @@ interface BlockDef {
         plainTextString?: string | null;
         /** Path appended to valuePath for ES/listing search (e.g. 'allText'). null = valuePath used directly. */
         searchField?: string | null;
-        /** Path to get display value for table/card rendering (e.g. 'allText'). null = value itself. */
-        displayValue?: string | null;
     };
     validation: {
         /** Name of the "is populated" validator fn (resolved by consumer) */
@@ -1559,6 +1569,9 @@ declare const MONGO_SCHEMA_PRESETS: {
     readonly string: {
         readonly type: StringConstructor;
     };
+    readonly array: {
+        readonly type: ArrayConstructor;
+    };
 };
 declare const ELASTIC_MAPPING_PRESETS: {
     readonly largeText: {
@@ -1569,6 +1582,22 @@ declare const ELASTIC_MAPPING_PRESETS: {
             };
         };
     };
+    readonly audioTranscription: {
+        readonly properties: {
+            readonly transcription: {
+                readonly properties: {
+                    readonly result: {
+                        readonly properties: {
+                            readonly finalText: {
+                                readonly type: "text";
+                                readonly analyzer: "LargeTextAnalyzer";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 };
 declare const CHUNKING_PRESETS: {
     readonly lexicalSemantic: {
@@ -1609,8 +1638,24 @@ declare class BlockRegistry {
     getQualBlocks(): string[];
     /** Get compType strings for all quant blocks. */
     getQuantBlocks(): string[];
+    /**
+     * 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: {
+        comp: string;
+        props?: any;
+    }): boolean;
     /** Check if a specific block has a specific capability. */
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * 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: string): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
     /**

package/dist/browser.d.ts

@@ -1429,6 +1429,18 @@ interface BlockDef {
     compName: string;
     category: 'text' | 'selection' | 'tags' | 'date' | 'number' | 'media' | 'structural' | 'special';
     qualQuant: 'qual' | 'quant' | null;
+    /**
+     * Optional gate that downgrades a block instance from its declared qualQuant unless
+     * ALL conditions match. Used for blocks whose qual-ness depends on a per-instance prop
+     * (e.g. AudioInput is only qual when `props.transcription.enable === true`).
+     *
+     * Each condition is a dotted path into `block.props` with a required value.
+     * No conditions / undefined → block's qualQuant applies unconditionally.
+     */
+    qualConditions?: Array<{
+        propPath: string;
+        equals: any;
+    }>;
     /** Mongoose schema type — the actual value returned to compToTypeMap (e.g. { type: Object }) */
     mongoSchemaType: Record<string, any>;
     /** Elasticsearch mapping shape — used directly by generateMappingsFromTpl */
@@ -1440,8 +1452,6 @@ interface BlockDef {
         plainTextString?: string | null;
         /** Path appended to valuePath for ES/listing search (e.g. 'allText'). null = valuePath used directly. */
         searchField?: string | null;
-        /** Path to get display value for table/card rendering (e.g. 'allText'). null = value itself. */
-        displayValue?: string | null;
     };
     validation: {
         /** Name of the "is populated" validator fn (resolved by consumer) */
@@ -1559,6 +1569,9 @@ declare const MONGO_SCHEMA_PRESETS: {
     readonly string: {
         readonly type: StringConstructor;
     };
+    readonly array: {
+        readonly type: ArrayConstructor;
+    };
 };
 declare const ELASTIC_MAPPING_PRESETS: {
     readonly largeText: {
@@ -1569,6 +1582,22 @@ declare const ELASTIC_MAPPING_PRESETS: {
             };
         };
     };
+    readonly audioTranscription: {
+        readonly properties: {
+            readonly transcription: {
+                readonly properties: {
+                    readonly result: {
+                        readonly properties: {
+                            readonly finalText: {
+                                readonly type: "text";
+                                readonly analyzer: "LargeTextAnalyzer";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 };
 declare const CHUNKING_PRESETS: {
     readonly lexicalSemantic: {
@@ -1609,8 +1638,24 @@ declare class BlockRegistry {
     getQualBlocks(): string[];
     /** Get compType strings for all quant blocks. */
     getQuantBlocks(): string[];
+    /**
+     * 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: {
+        comp: string;
+        props?: any;
+    }): boolean;
     /** Check if a specific block has a specific capability. */
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * 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: string): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
     /**

package/dist/browser.js

@@ -379,7 +379,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: {
@@ -389,6 +390,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 = {
@@ -430,8 +449,7 @@ var LexicalTextEditor = {
   // Field paths
   fieldPaths: {
     plainTextString: "allText",
-    searchField: "allText",
-    displayValue: "allText"
+    searchField: "allText"
   },
   // Validation
   validation: {
@@ -469,11 +487,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) {
@@ -520,12 +599,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/dist/browser.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/dist/node.d.mts

@@ -1436,6 +1436,18 @@ interface BlockDef {
     compName: string;
     category: 'text' | 'selection' | 'tags' | 'date' | 'number' | 'media' | 'structural' | 'special';
     qualQuant: 'qual' | 'quant' | null;
+    /**
+     * Optional gate that downgrades a block instance from its declared qualQuant unless
+     * ALL conditions match. Used for blocks whose qual-ness depends on a per-instance prop
+     * (e.g. AudioInput is only qual when `props.transcription.enable === true`).
+     *
+     * Each condition is a dotted path into `block.props` with a required value.
+     * No conditions / undefined → block's qualQuant applies unconditionally.
+     */
+    qualConditions?: Array<{
+        propPath: string;
+        equals: any;
+    }>;
     /** Mongoose schema type — the actual value returned to compToTypeMap (e.g. { type: Object }) */
     mongoSchemaType: Record<string, any>;
     /** Elasticsearch mapping shape — used directly by generateMappingsFromTpl */
@@ -1447,8 +1459,6 @@ interface BlockDef {
         plainTextString?: string | null;
         /** Path appended to valuePath for ES/listing search (e.g. 'allText'). null = valuePath used directly. */
         searchField?: string | null;
-        /** Path to get display value for table/card rendering (e.g. 'allText'). null = value itself. */
-        displayValue?: string | null;
     };
     validation: {
         /** Name of the "is populated" validator fn (resolved by consumer) */
@@ -1566,6 +1576,9 @@ declare const MONGO_SCHEMA_PRESETS: {
     readonly string: {
         readonly type: StringConstructor;
     };
+    readonly array: {
+        readonly type: ArrayConstructor;
+    };
 };
 declare const ELASTIC_MAPPING_PRESETS: {
     readonly largeText: {
@@ -1576,6 +1589,22 @@ declare const ELASTIC_MAPPING_PRESETS: {
             };
         };
     };
+    readonly audioTranscription: {
+        readonly properties: {
+            readonly transcription: {
+                readonly properties: {
+                    readonly result: {
+                        readonly properties: {
+                            readonly finalText: {
+                                readonly type: "text";
+                                readonly analyzer: "LargeTextAnalyzer";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 };
 declare const CHUNKING_PRESETS: {
     readonly lexicalSemantic: {
@@ -1616,8 +1645,24 @@ declare class BlockRegistry {
     getQualBlocks(): string[];
     /** Get compType strings for all quant blocks. */
     getQuantBlocks(): string[];
+    /**
+     * 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: {
+        comp: string;
+        props?: any;
+    }): boolean;
     /** Check if a specific block has a specific capability. */
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * 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: string): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
     /**

package/dist/node.d.ts

@@ -1436,6 +1436,18 @@ interface BlockDef {
     compName: string;
     category: 'text' | 'selection' | 'tags' | 'date' | 'number' | 'media' | 'structural' | 'special';
     qualQuant: 'qual' | 'quant' | null;
+    /**
+     * Optional gate that downgrades a block instance from its declared qualQuant unless
+     * ALL conditions match. Used for blocks whose qual-ness depends on a per-instance prop
+     * (e.g. AudioInput is only qual when `props.transcription.enable === true`).
+     *
+     * Each condition is a dotted path into `block.props` with a required value.
+     * No conditions / undefined → block's qualQuant applies unconditionally.
+     */
+    qualConditions?: Array<{
+        propPath: string;
+        equals: any;
+    }>;
     /** Mongoose schema type — the actual value returned to compToTypeMap (e.g. { type: Object }) */
     mongoSchemaType: Record<string, any>;
     /** Elasticsearch mapping shape — used directly by generateMappingsFromTpl */
@@ -1447,8 +1459,6 @@ interface BlockDef {
         plainTextString?: string | null;
         /** Path appended to valuePath for ES/listing search (e.g. 'allText'). null = valuePath used directly. */
         searchField?: string | null;
-        /** Path to get display value for table/card rendering (e.g. 'allText'). null = value itself. */
-        displayValue?: string | null;
     };
     validation: {
         /** Name of the "is populated" validator fn (resolved by consumer) */
@@ -1566,6 +1576,9 @@ declare const MONGO_SCHEMA_PRESETS: {
     readonly string: {
         readonly type: StringConstructor;
     };
+    readonly array: {
+        readonly type: ArrayConstructor;
+    };
 };
 declare const ELASTIC_MAPPING_PRESETS: {
     readonly largeText: {
@@ -1576,6 +1589,22 @@ declare const ELASTIC_MAPPING_PRESETS: {
             };
         };
     };
+    readonly audioTranscription: {
+        readonly properties: {
+            readonly transcription: {
+                readonly properties: {
+                    readonly result: {
+                        readonly properties: {
+                            readonly finalText: {
+                                readonly type: "text";
+                                readonly analyzer: "LargeTextAnalyzer";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 };
 declare const CHUNKING_PRESETS: {
     readonly lexicalSemantic: {
@@ -1616,8 +1645,24 @@ declare class BlockRegistry {
     getQualBlocks(): string[];
     /** Get compType strings for all quant blocks. */
     getQuantBlocks(): string[];
+    /**
+     * 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: {
+        comp: string;
+        props?: any;
+    }): boolean;
     /** Check if a specific block has a specific capability. */
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
+    /**
+     * 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: string): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
     /**