@okf/ootils 1.3.4 → 1.3.6

package/dist/browser.d.mts

@@ -31,4 +31,124 @@ interface RichTextValue {
 type TagNameInput = string | number | RichTextValue | null | undefined;
 declare const genTagId: (tagName: TagNameInput) => string;
 
-export { deleteVal, genTagId, getVal, setVal };
+/**
+ * Converts a value to an array, ensuring the result is always an array type.
+ *
+ * This utility function normalizes input values by:
+ * - Returning the input unchanged if it's already an array
+ * - Wrapping single values in an array
+ * - Preserving meaningful falsy values (false, 0) by wrapping them in arrays
+ * - Converting other falsy values (null, undefined, empty string) to empty arrays
+ *
+ * @template T - The type of the input value(s)
+ * @param {T | T[] | null | undefined | false | 0} property - The value to convert to an array
+ * @returns {T[]} An array containing the input value(s)
+ *
+ * @example
+ * ```typescript
+ * toArray("hello")        // ["hello"]
+ * toArray(["a", "b"])     // ["a", "b"] (unchanged)
+ * toArray(42)             // [42]
+ * toArray(false)          // [false] (preserved)
+ * toArray(0)              // [0] (preserved)
+ * toArray(null)           // []
+ * toArray(undefined)      // []
+ * toArray("")             // []
+ * ```
+ */
+declare const toArray: <T>(property: T | T[] | null | undefined | false | 0) => T[];
+
+interface Block {
+    [key: string]: any;
+    comp?: string;
+    valuePath?: string;
+    blocks?: Block[];
+}
+interface ExtractedBlock extends Block {
+    sectionStack: Section[];
+    blockPath: string;
+}
+interface Section {
+    [key: string]: any;
+    blocks?: Block[];
+}
+interface Template {
+    category: string;
+    kp_templates?: {
+        [spaceId: string]: SpaceConfig;
+    } & {
+        myProfileConfig?: Block[];
+    };
+    kp_settings?: Block[];
+}
+interface SpaceConfig {
+    builder?: 'FormBuilder' | 'MetaBuilder' | 'kp_settings' | string;
+    configs?: Block[] | {
+        inputs: {
+            [key: string]: Block;
+        };
+    };
+    subSpaces?: SpaceConfig[];
+}
+type BuilderType = 'FormBuilder' | 'MetaBuilder' | 'kp_settings' | string;
+/**
+ * Extracts all blocks from a template configuration, preserving their hierarchical context.
+ *
+ * This function traverses template structures and extracts individual block configurations
+ * while maintaining information about their location (blockPath) and parent sections
+ * (sectionStack). This metadata is crucial for:
+ * - Updating block properties at their exact location
+ * - Handling display conditions that affect entire sections
+ * - Managing nested block hierarchies in form builders
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {Template} params.tpl - The template configuration to extract blocks from
+ * @param {BuilderType[]} [params.buildersWhitelist] - Optional list of builders to extract from.
+ *   If provided, only blocks from these builders will be included
+ * @returns {ExtractedBlock[]} Array of blocks with added sectionStack and blockPath metadata
+ *
+ * @example
+ * ```typescript
+ * const blocks = extractAllBlocksFromTpl({
+ *   tpl: templateConfig,
+ *   buildersWhitelist: ['FormBuilder', 'kp_settings']
+ * });
+ *
+ * // Each block will have:
+ * // - Original block properties (type, label, valuePath, etc.)
+ * // - sectionStack: Array of parent sections for display condition handling
+ * // - blockPath: Dot-notation path for precise updates (e.g., "kp_templates.header.configs.0")
+ * ```
+ */
+declare const extractAllBlocksFromTpl: ({ tpl, buildersWhitelist }: {
+    tpl: Template;
+    buildersWhitelist?: BuilderType[];
+}) => ExtractedBlock[];
+/**
+ * Recursively extracts blocks from a hierarchical data structure.
+ *
+ * This is the core traversal function that handles nested sections and blocks.
+ * It preserves two critical pieces of metadata:
+ *
+ * 1. **sectionStack**: Array of parent sections - Essential for display condition handling.
+ *    When sections have display conditions, we need to know which blocks belong to
+ *    hidden sections to exclude them from indexes and processing.
+ *
+ * 2. **blockPath**: Dot-notation path to the block's location - Required for precise updates.
+ *    Used when modifying block properties or updating valuePaths in display conditions.
+ *    See 'modifyValuesAndValuePaths' for detailed usage.
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {Block[]} params.data - Array of blocks/sections to process
+ * @param {Function} params.cb - Callback function to handle each extracted block
+ * @param {Section[]} params.sectionStack - Current stack of parent sections
+ * @param {string} params.blockPathPrefix - Current path prefix for building blockPath
+ */
+declare const _recursExtractBlocks: ({ data, cb, sectionStack, blockPathPrefix }: {
+    data: Block[];
+    cb: (block: ExtractedBlock) => void;
+    sectionStack?: Section[];
+    blockPathPrefix?: string;
+}) => void;
+
+export { deleteVal, extractAllBlocksFromTpl, genTagId, getVal, _recursExtractBlocks as recursivelyExtractBlocks, setVal, toArray };

package/dist/browser.d.ts

@@ -31,4 +31,124 @@ interface RichTextValue {
 type TagNameInput = string | number | RichTextValue | null | undefined;
 declare const genTagId: (tagName: TagNameInput) => string;
 
-export { deleteVal, genTagId, getVal, setVal };
+/**
+ * Converts a value to an array, ensuring the result is always an array type.
+ *
+ * This utility function normalizes input values by:
+ * - Returning the input unchanged if it's already an array
+ * - Wrapping single values in an array
+ * - Preserving meaningful falsy values (false, 0) by wrapping them in arrays
+ * - Converting other falsy values (null, undefined, empty string) to empty arrays
+ *
+ * @template T - The type of the input value(s)
+ * @param {T | T[] | null | undefined | false | 0} property - The value to convert to an array
+ * @returns {T[]} An array containing the input value(s)
+ *
+ * @example
+ * ```typescript
+ * toArray("hello")        // ["hello"]
+ * toArray(["a", "b"])     // ["a", "b"] (unchanged)
+ * toArray(42)             // [42]
+ * toArray(false)          // [false] (preserved)
+ * toArray(0)              // [0] (preserved)
+ * toArray(null)           // []
+ * toArray(undefined)      // []
+ * toArray("")             // []
+ * ```
+ */
+declare const toArray: <T>(property: T | T[] | null | undefined | false | 0) => T[];
+
+interface Block {
+    [key: string]: any;
+    comp?: string;
+    valuePath?: string;
+    blocks?: Block[];
+}
+interface ExtractedBlock extends Block {
+    sectionStack: Section[];
+    blockPath: string;
+}
+interface Section {
+    [key: string]: any;
+    blocks?: Block[];
+}
+interface Template {
+    category: string;
+    kp_templates?: {
+        [spaceId: string]: SpaceConfig;
+    } & {
+        myProfileConfig?: Block[];
+    };
+    kp_settings?: Block[];
+}
+interface SpaceConfig {
+    builder?: 'FormBuilder' | 'MetaBuilder' | 'kp_settings' | string;
+    configs?: Block[] | {
+        inputs: {
+            [key: string]: Block;
+        };
+    };
+    subSpaces?: SpaceConfig[];
+}
+type BuilderType = 'FormBuilder' | 'MetaBuilder' | 'kp_settings' | string;
+/**
+ * Extracts all blocks from a template configuration, preserving their hierarchical context.
+ *
+ * This function traverses template structures and extracts individual block configurations
+ * while maintaining information about their location (blockPath) and parent sections
+ * (sectionStack). This metadata is crucial for:
+ * - Updating block properties at their exact location
+ * - Handling display conditions that affect entire sections
+ * - Managing nested block hierarchies in form builders
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {Template} params.tpl - The template configuration to extract blocks from
+ * @param {BuilderType[]} [params.buildersWhitelist] - Optional list of builders to extract from.
+ *   If provided, only blocks from these builders will be included
+ * @returns {ExtractedBlock[]} Array of blocks with added sectionStack and blockPath metadata
+ *
+ * @example
+ * ```typescript
+ * const blocks = extractAllBlocksFromTpl({
+ *   tpl: templateConfig,
+ *   buildersWhitelist: ['FormBuilder', 'kp_settings']
+ * });
+ *
+ * // Each block will have:
+ * // - Original block properties (type, label, valuePath, etc.)
+ * // - sectionStack: Array of parent sections for display condition handling
+ * // - blockPath: Dot-notation path for precise updates (e.g., "kp_templates.header.configs.0")
+ * ```
+ */
+declare const extractAllBlocksFromTpl: ({ tpl, buildersWhitelist }: {
+    tpl: Template;
+    buildersWhitelist?: BuilderType[];
+}) => ExtractedBlock[];
+/**
+ * Recursively extracts blocks from a hierarchical data structure.
+ *
+ * This is the core traversal function that handles nested sections and blocks.
+ * It preserves two critical pieces of metadata:
+ *
+ * 1. **sectionStack**: Array of parent sections - Essential for display condition handling.
+ *    When sections have display conditions, we need to know which blocks belong to
+ *    hidden sections to exclude them from indexes and processing.
+ *
+ * 2. **blockPath**: Dot-notation path to the block's location - Required for precise updates.
+ *    Used when modifying block properties or updating valuePaths in display conditions.
+ *    See 'modifyValuesAndValuePaths' for detailed usage.
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {Block[]} params.data - Array of blocks/sections to process
+ * @param {Function} params.cb - Callback function to handle each extracted block
+ * @param {Section[]} params.sectionStack - Current stack of parent sections
+ * @param {string} params.blockPathPrefix - Current path prefix for building blockPath
+ */
+declare const _recursExtractBlocks: ({ data, cb, sectionStack, blockPathPrefix }: {
+    data: Block[];
+    cb: (block: ExtractedBlock) => void;
+    sectionStack?: Section[];
+    blockPathPrefix?: string;
+}) => void;
+
+export { deleteVal, extractAllBlocksFromTpl, genTagId, getVal, _recursExtractBlocks as recursivelyExtractBlocks, setVal, toArray };

package/dist/browser.js

@@ -21,9 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browser_exports = {};
 __export(browser_exports, {
   deleteVal: () => deleteVal,
+  extractAllBlocksFromTpl: () => extractAllBlocksFromTpl,
   genTagId: () => genTagId,
   getVal: () => getVal,
-  setVal: () => setVal
+  recursivelyExtractBlocks: () => _recursExtractBlocks,
+  setVal: () => setVal,
+  toArray: () => toArray
 });
 module.exports = __toCommonJS(browser_exports);
 
@@ -182,10 +185,132 @@ var genTagId = (tagName) => {
   toReturn = toReturn.replace(/\+/g, "plus");
   return toReturn.replace(/^_+|_+$/, "");
 };
+
+// src/utils/toArray.ts
+var toArray = (property) => {
+  if (!property && (property !== false && property !== 0)) return [];
+  if (Array.isArray(property)) return property;
+  return [property];
+};
+
+// src/utils/extractAllBlocksFromTpl.ts
+var extractAllBlocksFromTpl = ({
+  tpl,
+  buildersWhitelist
+}) => {
+  if (tpl.category === "userProfiles") {
+    const allBlocksAry = [];
+    if (tpl.kp_templates?.myProfileConfig) {
+      _recursExtractBlocks({
+        data: tpl.kp_templates.myProfileConfig,
+        cb: (block) => allBlocksAry.push(block),
+        sectionStack: [],
+        blockPathPrefix: "kp_templates.myProfileConfig"
+      });
+    }
+    return allBlocksAry;
+  } else {
+    return extractAllBlocksFromStructuredTpls({ tpl, buildersWhitelist });
+  }
+};
+var _recursExtractBlocks = ({
+  data,
+  cb,
+  sectionStack = [],
+  blockPathPrefix = ""
+}) => {
+  data.forEach((d, idx) => {
+    if (!d.blocks) {
+      cb({
+        ...d,
+        sectionStack,
+        blockPath: `${blockPathPrefix}.${idx}`
+      });
+    } else {
+      _recursExtractBlocks({
+        data: d.blocks,
+        cb,
+        sectionStack: [...sectionStack, d],
+        blockPathPrefix: `${blockPathPrefix}.${idx}.blocks`
+      });
+    }
+  });
+};
+var extractAllBlocksFromStructuredTpls = ({
+  tpl,
+  buildersWhitelist
+}) => {
+  const allBlocksAry = [];
+  if (tpl.kp_templates) {
+    for (let spaceId in tpl.kp_templates) {
+      let conf = tpl.kp_templates[spaceId];
+      if (conf.builder && buildersWhitelist && !buildersWhitelist.includes(conf.builder)) {
+        continue;
+      }
+      if (!conf.subSpaces) {
+        _extractBlocksFromSomeBuilders({
+          conf,
+          confPath: `kp_templates.${spaceId}`,
+          allBlocksAry
+        });
+      } else {
+        conf.subSpaces.forEach((sub, subIdx) => {
+          if (sub.builder && buildersWhitelist && !buildersWhitelist.includes(sub.builder)) {
+            return;
+          }
+          _extractBlocksFromSomeBuilders({
+            conf: sub,
+            confPath: `kp_templates.${spaceId}.subSpaces.${subIdx}`,
+            allBlocksAry
+          });
+        });
+      }
+    }
+  }
+  if (buildersWhitelist && !buildersWhitelist.includes("kp_settings")) {
+    return allBlocksAry;
+  }
+  if (tpl.kp_settings && tpl.kp_settings.length > 0) {
+    _recursExtractBlocks({
+      data: tpl.kp_settings,
+      cb: (block) => allBlocksAry.push(block),
+      blockPathPrefix: "kp_settings"
+    });
+  }
+  return allBlocksAry;
+};
+var _extractBlocksFromSomeBuilders = ({
+  conf,
+  confPath,
+  allBlocksAry
+}) => {
+  if (conf.builder === "FormBuilder") {
+    const configs = conf.configs || [];
+    _recursExtractBlocks({
+      data: configs,
+      cb: (block) => allBlocksAry.push(block),
+      blockPathPrefix: `${confPath}.configs`
+    });
+  }
+  if (conf.builder === "MetaBuilder") {
+    const inputs = conf.configs?.inputs || {};
+    const inputBlockConfigsToPush = Object.keys(inputs).map((inputBlockKey) => {
+      const value = inputs[inputBlockKey];
+      return {
+        ...value,
+        blockPath: `${confPath}.configs.inputs.${inputBlockKey}`
+      };
+    });
+    allBlocksAry.push(...inputBlockConfigsToPush);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   deleteVal,
+  extractAllBlocksFromTpl,
   genTagId,
   getVal,
-  setVal
+  recursivelyExtractBlocks,
+  setVal,
+  toArray
 });

package/dist/browser.mjs

@@ -153,9 +153,131 @@ var genTagId = (tagName) => {
   toReturn = toReturn.replace(/\+/g, "plus");
   return toReturn.replace(/^_+|_+$/, "");
 };
+
+// src/utils/toArray.ts
+var toArray = (property) => {
+  if (!property && (property !== false && property !== 0)) return [];
+  if (Array.isArray(property)) return property;
+  return [property];
+};
+
+// src/utils/extractAllBlocksFromTpl.ts
+var extractAllBlocksFromTpl = ({
+  tpl,
+  buildersWhitelist
+}) => {
+  if (tpl.category === "userProfiles") {
+    const allBlocksAry = [];
+    if (tpl.kp_templates?.myProfileConfig) {
+      _recursExtractBlocks({
+        data: tpl.kp_templates.myProfileConfig,
+        cb: (block) => allBlocksAry.push(block),
+        sectionStack: [],
+        blockPathPrefix: "kp_templates.myProfileConfig"
+      });
+    }
+    return allBlocksAry;
+  } else {
+    return extractAllBlocksFromStructuredTpls({ tpl, buildersWhitelist });
+  }
+};
+var _recursExtractBlocks = ({
+  data,
+  cb,
+  sectionStack = [],
+  blockPathPrefix = ""
+}) => {
+  data.forEach((d, idx) => {
+    if (!d.blocks) {
+      cb({
+        ...d,
+        sectionStack,
+        blockPath: `${blockPathPrefix}.${idx}`
+      });
+    } else {
+      _recursExtractBlocks({
+        data: d.blocks,
+        cb,
+        sectionStack: [...sectionStack, d],
+        blockPathPrefix: `${blockPathPrefix}.${idx}.blocks`
+      });
+    }
+  });
+};
+var extractAllBlocksFromStructuredTpls = ({
+  tpl,
+  buildersWhitelist
+}) => {
+  const allBlocksAry = [];
+  if (tpl.kp_templates) {
+    for (let spaceId in tpl.kp_templates) {
+      let conf = tpl.kp_templates[spaceId];
+      if (conf.builder && buildersWhitelist && !buildersWhitelist.includes(conf.builder)) {
+        continue;
+      }
+      if (!conf.subSpaces) {
+        _extractBlocksFromSomeBuilders({
+          conf,
+          confPath: `kp_templates.${spaceId}`,
+          allBlocksAry
+        });
+      } else {
+        conf.subSpaces.forEach((sub, subIdx) => {
+          if (sub.builder && buildersWhitelist && !buildersWhitelist.includes(sub.builder)) {
+            return;
+          }
+          _extractBlocksFromSomeBuilders({
+            conf: sub,
+            confPath: `kp_templates.${spaceId}.subSpaces.${subIdx}`,
+            allBlocksAry
+          });
+        });
+      }
+    }
+  }
+  if (buildersWhitelist && !buildersWhitelist.includes("kp_settings")) {
+    return allBlocksAry;
+  }
+  if (tpl.kp_settings && tpl.kp_settings.length > 0) {
+    _recursExtractBlocks({
+      data: tpl.kp_settings,
+      cb: (block) => allBlocksAry.push(block),
+      blockPathPrefix: "kp_settings"
+    });
+  }
+  return allBlocksAry;
+};
+var _extractBlocksFromSomeBuilders = ({
+  conf,
+  confPath,
+  allBlocksAry
+}) => {
+  if (conf.builder === "FormBuilder") {
+    const configs = conf.configs || [];
+    _recursExtractBlocks({
+      data: configs,
+      cb: (block) => allBlocksAry.push(block),
+      blockPathPrefix: `${confPath}.configs`
+    });
+  }
+  if (conf.builder === "MetaBuilder") {
+    const inputs = conf.configs?.inputs || {};
+    const inputBlockConfigsToPush = Object.keys(inputs).map((inputBlockKey) => {
+      const value = inputs[inputBlockKey];
+      return {
+        ...value,
+        blockPath: `${confPath}.configs.inputs.${inputBlockKey}`
+      };
+    });
+    allBlocksAry.push(...inputBlockConfigsToPush);
+  }
+};
 export {
   deleteVal,
+  extractAllBlocksFromTpl,
   genTagId,
   getVal,
-  setVal
+  _recursExtractBlocks as recursivelyExtractBlocks,
+  setVal,
+  toArray
 };

package/dist/node.d.mts

@@ -34,6 +34,126 @@ interface RichTextValue {
 type TagNameInput = string | number | RichTextValue | null | undefined;
 declare const genTagId: (tagName: TagNameInput) => string;
 
+/**
+ * Converts a value to an array, ensuring the result is always an array type.
+ *
+ * This utility function normalizes input values by:
+ * - Returning the input unchanged if it's already an array
+ * - Wrapping single values in an array
+ * - Preserving meaningful falsy values (false, 0) by wrapping them in arrays
+ * - Converting other falsy values (null, undefined, empty string) to empty arrays
+ *
+ * @template T - The type of the input value(s)
+ * @param {T | T[] | null | undefined | false | 0} property - The value to convert to an array
+ * @returns {T[]} An array containing the input value(s)
+ *
+ * @example
+ * ```typescript
+ * toArray("hello")        // ["hello"]
+ * toArray(["a", "b"])     // ["a", "b"] (unchanged)
+ * toArray(42)             // [42]
+ * toArray(false)          // [false] (preserved)
+ * toArray(0)              // [0] (preserved)
+ * toArray(null)           // []
+ * toArray(undefined)      // []
+ * toArray("")             // []
+ * ```
+ */
+declare const toArray: <T>(property: T | T[] | null | undefined | false | 0) => T[];
+
+interface Block {
+    [key: string]: any;
+    comp?: string;
+    valuePath?: string;
+    blocks?: Block[];
+}
+interface ExtractedBlock extends Block {
+    sectionStack: Section[];
+    blockPath: string;
+}
+interface Section {
+    [key: string]: any;
+    blocks?: Block[];
+}
+interface Template$1 {
+    category: string;
+    kp_templates?: {
+        [spaceId: string]: SpaceConfig;
+    } & {
+        myProfileConfig?: Block[];
+    };
+    kp_settings?: Block[];
+}
+interface SpaceConfig {
+    builder?: 'FormBuilder' | 'MetaBuilder' | 'kp_settings' | string;
+    configs?: Block[] | {
+        inputs: {
+            [key: string]: Block;
+        };
+    };
+    subSpaces?: SpaceConfig[];
+}
+type BuilderType = 'FormBuilder' | 'MetaBuilder' | 'kp_settings' | string;
+/**
+ * Extracts all blocks from a template configuration, preserving their hierarchical context.
+ *
+ * This function traverses template structures and extracts individual block configurations
+ * while maintaining information about their location (blockPath) and parent sections
+ * (sectionStack). This metadata is crucial for:
+ * - Updating block properties at their exact location
+ * - Handling display conditions that affect entire sections
+ * - Managing nested block hierarchies in form builders
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {Template} params.tpl - The template configuration to extract blocks from
+ * @param {BuilderType[]} [params.buildersWhitelist] - Optional list of builders to extract from.
+ *   If provided, only blocks from these builders will be included
+ * @returns {ExtractedBlock[]} Array of blocks with added sectionStack and blockPath metadata
+ *
+ * @example
+ * ```typescript
+ * const blocks = extractAllBlocksFromTpl({
+ *   tpl: templateConfig,
+ *   buildersWhitelist: ['FormBuilder', 'kp_settings']
+ * });
+ *
+ * // Each block will have:
+ * // - Original block properties (type, label, valuePath, etc.)
+ * // - sectionStack: Array of parent sections for display condition handling
+ * // - blockPath: Dot-notation path for precise updates (e.g., "kp_templates.header.configs.0")
+ * ```
+ */
+declare const extractAllBlocksFromTpl: ({ tpl, buildersWhitelist }: {
+    tpl: Template$1;
+    buildersWhitelist?: BuilderType[];
+}) => ExtractedBlock[];
+/**
+ * Recursively extracts blocks from a hierarchical data structure.
+ *
+ * This is the core traversal function that handles nested sections and blocks.
+ * It preserves two critical pieces of metadata:
+ *
+ * 1. **sectionStack**: Array of parent sections - Essential for display condition handling.
+ *    When sections have display conditions, we need to know which blocks belong to
+ *    hidden sections to exclude them from indexes and processing.
+ *
+ * 2. **blockPath**: Dot-notation path to the block's location - Required for precise updates.
+ *    Used when modifying block properties or updating valuePaths in display conditions.
+ *    See 'modifyValuesAndValuePaths' for detailed usage.
+ *
+ * @param {Object} params - Extraction parameters
+ * @param {Block[]} params.data - Array of blocks/sections to process
+ * @param {Function} params.cb - Callback function to handle each extracted block
+ * @param {Section[]} params.sectionStack - Current stack of parent sections
+ * @param {string} params.blockPathPrefix - Current path prefix for building blockPath
+ */
+declare const _recursExtractBlocks: ({ data, cb, sectionStack, blockPathPrefix }: {
+    data: Block[];
+    cb: (block: ExtractedBlock) => void;
+    sectionStack?: Section[];
+    blockPathPrefix?: string;
+}) => void;
+
 interface DbConnections {
     [clusterName: string]: Connection;
 }
@@ -175,4 +295,4 @@ declare const getAIConfigs: ({ tenant }: GetAIConfigsParams) => Promise<AIconfig
 declare const connectToRedis: () => Promise<void>;
 declare const getRedisClient: () => IORedis;
 
-export { connectToRedis, deleteVal, genTagId, getAIConfigs, getAnnotationsModelByTenant, getDbByTenant, getModelByTenant, getPlatformConfigsModelByTenant, getRedisClient, getTpl, getTplModelByTenant, getVal, initializeGlobalConfig, multiConnectToMongoDB, setVal, updateGlobalConfig };
+export { connectToRedis, deleteVal, extractAllBlocksFromTpl, genTagId, getAIConfigs, getAnnotationsModelByTenant, getDbByTenant, getModelByTenant, getPlatformConfigsModelByTenant, getRedisClient, getTpl, getTplModelByTenant, getVal, initializeGlobalConfig, multiConnectToMongoDB, _recursExtractBlocks as recursivelyExtractBlocks, setVal, toArray, updateGlobalConfig };