@okf/ootils 1.3.3 → 1.3.5

package/dist/browser.d.mts

@@ -0,0 +1,128 @@
+declare const deleteVal: (data: any, valuePath: string) => any;
+
+type ValuePath = string | string[];
+type DataValue = any;
+interface GetValOptions {
+    flattenIfValueIsArray?: boolean;
+}
+
+declare const setVal: (data: any, valuePath: string, value: DataValue) => any;
+
+/**
+ *
+ * @param {*} data
+ * @param {*} valuePath
+ * @returns
+ * - if target value is an array found inside an array, it will flatten them out so that there is a single array
+ * - if target value is an array NOT found inside an array, that will be returned as is.
+ * - if target value is a string/object/number/boolean found inside an array of arrays, then the inner arrays will be flattened so that there is a single array
+ * - if target value is a string/object/number/boolean NOT found inside an array, it will be returned as is.
+ */
+declare const getVal: (data: any, valuePath: ValuePath, options?: GetValOptions, depthIdx?: number) => any;
+
+interface RichTextBlock {
+    text: string;
+    [key: string]: any;
+}
+interface RichTextValue {
+    blocks: RichTextBlock[];
+    [key: string]: any;
+}
+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 {
+    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[];
+
+export { deleteVal, extractAllBlocksFromTpl, genTagId, getVal, setVal, toArray };

package/dist/browser.d.ts

@@ -0,0 +1,128 @@
+declare const deleteVal: (data: any, valuePath: string) => any;
+
+type ValuePath = string | string[];
+type DataValue = any;
+interface GetValOptions {
+    flattenIfValueIsArray?: boolean;
+}
+
+declare const setVal: (data: any, valuePath: string, value: DataValue) => any;
+
+/**
+ *
+ * @param {*} data
+ * @param {*} valuePath
+ * @returns
+ * - if target value is an array found inside an array, it will flatten them out so that there is a single array
+ * - if target value is an array NOT found inside an array, that will be returned as is.
+ * - if target value is a string/object/number/boolean found inside an array of arrays, then the inner arrays will be flattened so that there is a single array
+ * - if target value is a string/object/number/boolean NOT found inside an array, it will be returned as is.
+ */
+declare const getVal: (data: any, valuePath: ValuePath, options?: GetValOptions, depthIdx?: number) => any;
+
+interface RichTextBlock {
+    text: string;
+    [key: string]: any;
+}
+interface RichTextValue {
+    blocks: RichTextBlock[];
+    [key: string]: any;
+}
+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 {
+    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[];
+
+export { deleteVal, extractAllBlocksFromTpl, genTagId, getVal, setVal, toArray };

package/dist/browser.js

@@ -0,0 +1,314 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  deleteVal: () => deleteVal,
+  extractAllBlocksFromTpl: () => extractAllBlocksFromTpl,
+  genTagId: () => genTagId,
+  getVal: () => getVal,
+  setVal: () => setVal,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/utils/getterSetterDeleter/utils/set_deleteVal.ts
+var set_deleteVal = (action, data, valuePath, value) => {
+  if (valuePath === void 0) return;
+  if (valuePath === null && action === "set") {
+    data = value;
+    return data;
+  }
+  let dataRef = data;
+  const keysArray = valuePath.split(".");
+  const len = keysArray.length;
+  let valIsUndefined = false;
+  for (let i = 0; i < len - 1; i++) {
+    const key = keysArray[i];
+    if (!dataRef[key]) {
+      if (action === "set") {
+        const nextKey = keysArray[i + 1];
+        if (nextKey && !isNaN(parseInt(nextKey))) {
+          dataRef[key] = [];
+        } else {
+          dataRef[key] = {};
+        }
+      } else {
+        valIsUndefined = true;
+        break;
+      }
+    }
+    dataRef = dataRef[key];
+  }
+  if (valIsUndefined) return void 0;
+  if (action === "set") {
+    dataRef[keysArray[len - 1]] = value;
+    return data;
+  } else if (action === "delete") {
+    if (Array.isArray(dataRef)) {
+      dataRef.splice(parseInt(keysArray[len - 1]), 1);
+    } else {
+      delete dataRef[keysArray[len - 1]];
+    }
+    return data;
+  }
+};
+
+// src/utils/getterSetterDeleter/deleteVal.ts
+var deleteVal = (data, valuePath) => {
+  return set_deleteVal("delete", data, valuePath);
+};
+
+// src/utils/getterSetterDeleter/setVal.ts
+var setVal = (data, valuePath, value) => {
+  return set_deleteVal("set", data, valuePath, value);
+};
+
+// src/utils/getterSetterDeleter/utils/flattenArrayOfArrays.ts
+var flattenArrayOfArrays = ({
+  array,
+  flattenLastArray = true,
+  toReturn = []
+}) => {
+  array.map((ary) => {
+    if (Array.isArray(ary)) {
+      if (flattenLastArray === true) {
+        if (ary.some((childAry) => !Array.isArray(childAry))) {
+          toReturn.push(ary);
+        } else {
+          flattenArrayOfArrays({ array: ary, flattenLastArray, toReturn });
+        }
+      } else {
+        flattenArrayOfArrays({ array: ary, flattenLastArray, toReturn });
+      }
+    } else {
+      toReturn.push(ary);
+    }
+  });
+  return toReturn;
+};
+
+// src/utils/getterSetterDeleter/getVal.ts
+var getVal = (data, valuePath, options = {}, depthIdx = 0) => {
+  let value = null;
+  const getFinalVal = (data2, valuePath2, options2, depthIdx2) => {
+    return Array.isArray(data2) ? data2.map((R) => getValV2_getter(R, valuePath2, options2, depthIdx2)) : getValV2_getter(data2, valuePath2, options2, depthIdx2);
+  };
+  if (Array.isArray(valuePath)) {
+    for (let i = 0; i < valuePath.length; i++) {
+      value = getFinalVal(data, valuePath[i], options, depthIdx);
+      if (value) break;
+    }
+  } else {
+    value = getFinalVal(data, valuePath, options, depthIdx);
+  }
+  return value;
+};
+var getValV2_getter = (data, valuePath, options, depthIdx) => {
+  const { flattenIfValueIsArray = true } = options;
+  if (valuePath === null) return data;
+  let dataRef = data;
+  const keysArray = valuePath.split(".");
+  const len = keysArray.length;
+  let valIsUndefined = false;
+  let thisIterationFoundAry = false;
+  for (let i = 0; i < len - 1; i++) {
+    const key = keysArray[i];
+    if (!thisIterationFoundAry) {
+      if (!dataRef[key]) {
+        valIsUndefined = true;
+        break;
+      }
+      dataRef = dataRef[key];
+    } else {
+      const nestedAryResponse = dataRef.map((dataRefItem) => {
+        const remainingValuePath = keysArray.filter((dd, ii) => ii >= i).join(".");
+        return getVal(dataRefItem, remainingValuePath, options, depthIdx + 1);
+      });
+      return flattenArrayOfArrays({
+        array: nestedAryResponse,
+        flattenLastArray: depthIdx === 0 && flattenIfValueIsArray === false ? false : true
+      });
+    }
+    if (Array.isArray(dataRef) && Number.isNaN(parseInt(keysArray[i + 1]))) thisIterationFoundAry = true;
+  }
+  if (valIsUndefined) return void 0;
+  if (thisIterationFoundAry) {
+    const toReturn = dataRef.map((d) => d[keysArray[len - 1]]);
+    return flattenArrayOfArrays({
+      array: toReturn,
+      flattenLastArray: flattenIfValueIsArray
+    });
+  }
+  return dataRef[keysArray[len - 1]];
+};
+
+// src/utils/genTagId.ts
+var convertFromRichText = (value) => {
+  if (!value) return "";
+  let val = "";
+  if (typeof value === "string" || typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "object" && "blocks" in value && Array.isArray(value.blocks)) {
+    for (let i = 0; i < value.blocks.length; i++) {
+      const block = value.blocks[i];
+      if (block && block.text && block.text.length > 0) {
+        val = val + block.text;
+      }
+    }
+  }
+  return val;
+};
+var genTagId = (tagName) => {
+  let toReturn = convertFromRichText(tagName);
+  const regex = /[^\p{L}\p{N}\+]+/gui;
+  toReturn = toReturn.trim().toLowerCase().replace(regex, "_");
+  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,
+  toArray
+});