@wavy/fn 0.0.1

package/dist/main.cjs

@@ -0,0 +1,1102 @@
+"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/main.ts
+var main_exports = {};
+__export(main_exports, {
+  addArticle: () => addArticle,
+  arrayWithConst: () => arrayWithConst,
+  asyncRun: () => asyncRun,
+  averageOf: () => averageOf,
+  blankSpaces: () => blankSpaces,
+  buildArray: () => buildArray,
+  camelCaseToLetter: () => camelCaseToLetter,
+  classNameExt: () => classNameExt,
+  classNameResolver: () => classNameResolver,
+  coerceIn: () => coerceIn,
+  copyToClipboard: () => copyToClipboard,
+  count: () => count,
+  dataSearcher: () => dataSearcher,
+  distinct: () => distinct,
+  drop: () => drop,
+  dropLast: () => dropLast,
+  dropLastWhile: () => dropLastWhile,
+  dropWhile: () => dropWhile,
+  format: () => format,
+  formatGCTRegNo: () => formatGCTRegNo,
+  formatInvoiceNo: () => formatInvoiceNo,
+  getCaps: () => getCaps,
+  getFileExt: () => getFileExt,
+  group: () => group,
+  hasIndex: () => hasIndex,
+  ifDefined: () => ifDefined,
+  ifEmpty: () => ifEmpty,
+  inRange: () => inRange,
+  indexOf: () => indexOf,
+  indices: () => indices,
+  inferFilename: () => inferFilename,
+  insertAt: () => insertAt,
+  isEmpty: () => isEmpty,
+  isFile: () => isFile,
+  isLetter: () => isLetter,
+  isNumber: () => isNumber,
+  lastIndex: () => lastIndex,
+  map: () => map,
+  mapToArray: () => mapToArray,
+  maxOf: () => maxOf,
+  minOf: () => minOf,
+  negate: () => negate,
+  ordinalIndicator: () => ordinalIndicator,
+  overwrite: () => overwrite,
+  pluralize: () => pluralize,
+  poll: () => poll,
+  random: () => random,
+  range: () => range,
+  readClipboardText: () => readClipboardText,
+  removeAll: () => removeAll,
+  repeat: () => repeat,
+  run: () => run,
+  serverDataAdapter: () => serverDataAdapter,
+  someValuesEmpty: () => someValuesEmpty,
+  sort: () => sort,
+  strictArray: () => strictArray,
+  stringToSearch: () => stringToSearch,
+  subObjectList: () => subObjectList,
+  sumOf: () => sumOf,
+  take: () => take,
+  takeLast: () => takeLast,
+  takeLastWhile: () => takeLastWhile,
+  takeWhile: () => takeWhile,
+  timeDuration: () => timeDuration,
+  toNumber: () => toNumber,
+  toObject: () => toObject,
+  trimString: () => trimString,
+  undefinedIfEmpty: () => undefinedIfEmpty,
+  upperFirst: () => upperFirst,
+  windowed: () => windowed
+});
+module.exports = __toCommonJS(main_exports);
+
+// src/helper-functions/components/time/TimeManager.ts
+var TimeManager = class _TimeManager {
+  constructor(locale = "en-jm") {
+    this.locale = locale;
+  }
+  periods = {
+    overview: {
+      getPrevious: (period) => {
+        if (period === "Today") return "Yesterday";
+        if (period === "All") return "None";
+        return period.replace("This", "Last");
+      }
+    }
+  };
+  metrics = {
+    second: {
+      pluginVals: [1e3],
+      unit: { fmt: "second", abv: "sec" },
+      get inMillis() {
+        return _TimeManager.calcInMillis(this.pluginVals);
+      }
+    },
+    get minute() {
+      return {
+        pluginVals: [...this.second.pluginVals, 60],
+        unit: { fmt: "minute", abv: "min" },
+        get inMillis() {
+          return _TimeManager.calcInMillis(this.pluginVals);
+        }
+      };
+    },
+    get hour() {
+      return {
+        pluginVals: [...this.minute.pluginVals, 60],
+        unit: { fmt: "hour", abv: "hr" },
+        get inMillis() {
+          return _TimeManager.calcInMillis(this.pluginVals);
+        }
+      };
+    },
+    get day() {
+      return {
+        pluginVals: [...this.hour.pluginVals, 24],
+        unit: { fmt: "day", abv: "d" },
+        get inMillis() {
+          return _TimeManager.calcInMillis(this.pluginVals);
+        }
+      };
+    },
+    get week() {
+      return {
+        pluginVals: [...this.day.pluginVals, 7],
+        unit: { fmt: "week", abv: "wk" },
+        get inMillis() {
+          return _TimeManager.calcInMillis(this.pluginVals);
+        }
+      };
+    },
+    get month() {
+      return {
+        pluginVals: [...this.day.pluginVals, 30.44],
+        unit: { fmt: "month", abv: "mo" },
+        inMillis: this.year.inMillis * (1 / 12)
+      };
+    },
+    get year() {
+      return {
+        pluginVals: [...this.day.pluginVals, 365],
+        unit: { fmt: "year", abv: "y" },
+        get inMillis() {
+          return _TimeManager.calcInMillis(this.pluginVals);
+        }
+      };
+    }
+  };
+  format(time, format2) {
+    if (!time) return "";
+    const convertedDate = typeof time === "number" ? new Date(time) : time === "now" ? new Date(Date.now()) : time;
+    let options = {};
+    switch (format2) {
+      case "HH:mm A":
+        options = { hour: "numeric", minute: "2-digit" };
+        break;
+      case "mm/dd/yyyy":
+        options = {
+          year: "numeric",
+          month: "2-digit",
+          day: "2-digit"
+        };
+        break;
+      case "mm/dd/yyyy HH:mm A":
+        options = {
+          year: "numeric",
+          month: "2-digit",
+          day: "2-digit",
+          hour: "numeric",
+          minute: "2-digit"
+        };
+        break;
+      default:
+        options = {
+          year: "numeric",
+          month: format2 === "MMMM" ? "long" : "short",
+          day: "numeric"
+        };
+        break;
+    }
+    const fmtDate = convertedDate.toLocaleDateString(this.locale, options);
+    if (format2 === "MMMM")
+      return takeWhile(fmtDate.split(""), (char) => char !== " ").join("");
+    if (format2 === "yyyy") return takeLast(fmtDate.split(""), 4).join("");
+    if (format2 === "MMM yyyy") {
+      const month = this.format(convertedDate, "MMMM");
+      const year = this.format(convertedDate, "yyyy");
+      return `${month} ${year}`;
+    }
+    if (format2 === "HH:mm A")
+      return takeLastWhile(fmtDate.split(""), (char) => char !== ",").join("").trim();
+    if (format2 === "MMM dd, yyyy | HH:mm A" || format2 === "MMM dd, yyyy at HH:mm A") {
+      const delimiter = format2 === "MMM dd, yyyy at HH:mm A" ? "at" : "|";
+      const time2 = this.format(convertedDate, "HH:mm A");
+      return [fmtDate, time2].join(` ${delimiter} `);
+    }
+    return fmtDate;
+  }
+  getDuration(from, to, options) {
+    const difference = new Date(to).getTime() - new Date(from).getTime();
+    const metrics = this.metrics;
+    const getFmtDuration = (duration2, unit) => `${duration2} ${options?.abvUnits ? unit.abv : unit.fmt}${duration2 > 1 ? "s" : ""}`;
+    const getDuration = (plugins) => plugins.reduce((prev, curr) => prev / curr);
+    const metric = (timeDifference = difference) => Object.keys(metrics).reduce((prev, curr) => {
+      const validPrev = prev;
+      const validCurr = curr;
+      if (!prev) return curr;
+      if (timeDifference >= metrics[validPrev].inMillis && timeDifference < metrics[validCurr].inMillis)
+        return prev;
+      return curr;
+    });
+    const duration = getDuration([difference, ...metrics[metric()].pluginVals]);
+    const flooredDuration = Math.floor(duration);
+    const fmtDuration = getFmtDuration(
+      flooredDuration,
+      flooredDuration ? metrics[metric()].unit : metrics.second.unit
+    );
+    if (!options?.disableRemainder) {
+      const remaindingDifference = difference % metrics[metric()].inMillis;
+      const remaindingMetric = metrics[metric(remaindingDifference)];
+      const remaindingDuration = getDuration([
+        remaindingDifference,
+        ...remaindingMetric.pluginVals
+      ]);
+      const roundedRemaindingDuration = Math.floor(remaindingDuration);
+      const fmtRoundedRemaindingDuration = getFmtDuration(
+        roundedRemaindingDuration,
+        remaindingMetric.unit
+      );
+      return roundedRemaindingDuration ? `${fmtDuration} ${fmtRoundedRemaindingDuration}` : fmtDuration;
+    }
+    return fmtDuration;
+  }
+  getTimeOfDay() {
+    const time = this.format("now", "HH:mm A");
+    const amOrPm = takeLast(time.split(""), 2).join("");
+    const hour = parseInt(
+      takeWhile(time.split(""), (value) => value !== ":").join("")
+    );
+    return amOrPm === "am" ? "morning" : hour < 5 ? "afternoon" : "evening";
+  }
+  static calcInMillis = (plugins) => plugins.reduce((prev, curr) => prev * curr);
+};
+var TimeManager_default = TimeManager;
+
+// src/helper-functions/components/formatter/number/NumberFormatter.ts
+var NumberFormatter = class _NumberFormatter {
+  static format(value, format2, options) {
+    switch (format2) {
+      case "money":
+        return _NumberFormatter.toMoney(value, options);
+      default:
+        return value.toLocaleString("en-us");
+    }
+  }
+  static toMoney(amount, options) {
+    const dollarSign = options?.excludeDollarSign ? "" : "$";
+    if (!amount) return dollarSign + (options?.dropDecimals ? "0" : "0.00");
+    if (options?.truncate) {
+      const strAmt = takeWhile(
+        `${amount}`.split(""),
+        (char) => char !== "."
+      ).join("");
+      const fmtMoney = (value, decimal) => {
+        const getTruncatedSuffix = () => {
+          if (strAmt.length <= 3) return "";
+          if (range(4, 7).includes(strAmt.length)) return "k";
+          if (range(7, 10).includes(strAmt.length)) return "m";
+          if (range(10, 13).includes(strAmt.length)) return "b";
+          if (range(13, 16).includes(strAmt.length)) return "t";
+        };
+        const fmtValue = parseInt(decimal) > 0 ? `${value}.${decimal}` : value;
+        return dollarSign + fmtValue + getTruncatedSuffix();
+      };
+      if (strAmt.length <= 3) return fmtMoney(strAmt, "0");
+      else {
+        const relevantDigits = takeLast(
+          windowed([...strAmt.split("")].reverse(), 3).map(
+            (arr) => arr.reverse()
+          ),
+          2
+        ).reverse();
+        return fmtMoney(relevantDigits[0].join(""), relevantDigits[1][0]);
+      }
+    }
+    return (amount < 0 ? "-" : options?.showSigns ? "+" : "") + dollarSign + amount.toLocaleString("en-US", {
+      minimumFractionDigits: options?.dropDecimals ? 0 : 2,
+      currency: "USD",
+      currencyDisplay: "symbol",
+      currencySign: "accounting",
+      signDisplay: "never"
+    });
+  }
+};
+var NumberFormatter_default = NumberFormatter;
+
+// src/helper-functions/components/input/InputManager.ts
+var InputManager = class {
+  static manualValidators = {
+    percent: (value) => StringFormatter_default.toNumber(value) <= 100 && run(value.split(".")?.[1], (dec) => dec ? dec.length <= 2 : true)
+  };
+  static formatters = {
+    money: {
+      format: (value) => take(
+        value.split(".").map(
+          (sect, idx) => idx === 0 ? `${NumberFormatter_default.format(StringFormatter_default.toNumber(sect))}` : take(sect.split(""), 2).join("")
+        ),
+        2
+      ).join("."),
+      unformat: (value) => `${StringFormatter_default.toNumber(value)}`
+    }
+  };
+  static separateNumbersFormatter(options = {
+    numbersPerGroup: 3,
+    separator: "-"
+  }) {
+    return {
+      format: (value) => {
+        let groupedValues = windowed(
+          value.split(""),
+          options.numbersPerGroup
+        ).map((v) => v.join(""));
+        if (options.groupCount) {
+          groupedValues = [
+            ...take(groupedValues, options.groupCount),
+            drop(groupedValues, options.groupCount).join("").replace(options.separator, "")
+          ].filter((v) => !isEmpty(v));
+        }
+        return groupedValues.join(options.separator);
+      },
+      unformat: (value) => {
+        const unformatted = value.replaceAll(options.separator, "");
+        return unformatted;
+      }
+    };
+  }
+};
+var InputManager_default = InputManager;
+
+// src/helper-functions/components/formatter/string/StringFormatter.ts
+var VOWELS = "aeiouy";
+var StringFormatter = class _StringFormatter {
+  static vowels = VOWELS;
+  static caseConverter = {
+    camelToLetter: (camelCase) => {
+      return camelCase.split("").map(
+        (char, charIdx) => charIdx === 0 ? char.toUpperCase() : char === char.toUpperCase() && char !== char.toLowerCase() ? ` ${char}` : char
+      ).join("");
+    }
+  };
+  static extract = {
+    capitalLetters: (value, count2) => {
+      return value.split("", count2).filter(
+        (char) => char === char.toUpperCase() && char !== char.toLowerCase()
+      );
+    }
+  };
+  static trimString(value, trim) {
+    let newValue = value;
+    while (newValue.endsWith(trim)) {
+      newValue = value.split("").reverse().join("").replace(trim, "").split("").reverse().join("");
+    }
+    return newValue;
+  }
+  static pluralize(value) {
+    return value[value.length - 1] === "s" ? value + "es" : value + "s";
+  }
+  static addArticle(value, article) {
+    let fmtArticle = "";
+    switch (article) {
+      case "a/an":
+        fmtArticle = VOWELS.includes(value?.[0].toLowerCase()) ? "An" : "A";
+        break;
+      default:
+        return article;
+    }
+    return `${fmtArticle.toLowerCase()} ${value}`;
+  }
+  static toSearch(from) {
+    return from.split("").filter((char) => char !== " ").join("").toLowerCase().trim();
+  }
+  static toMoney(from, options) {
+    return NumberFormatter_default.toMoney(_StringFormatter.toNumber(from), options);
+  }
+  static toTRN(from) {
+    return InputManager_default.separateNumbersFormatter().format(from);
+  }
+  static toNumber(value) {
+    const potentialNumber = take(value.split("."), 2).join(".").split("").map(
+      (char, idx) => idx === 0 && char === "-" ? char : "0123456789.".includes(char) ? char : ""
+    ).join("");
+    return isEmpty(potentialNumber.trim()) ? 0 : parseFloat(potentialNumber);
+  }
+  static upperFirst(value) {
+    return value.split("").map((char, idx) => idx === 0 ? char.toUpperCase() : char).join("");
+  }
+};
+var StringFormatter_default = StringFormatter;
+
+// src/helper-functions/components/formatter/object/ObjectFormatter.ts
+var ObjectFormatter = class {
+  static toString = {
+    name: (name) => name ? `${name.first} ${name.last}`.trim() : "no_name",
+    phoneNumber: (phoneNumber) => {
+      if (!phoneNumber) return "no_phone_number";
+      return `${phoneNumber.countryCode} (${phoneNumber.areaCode}) ${insertAt(
+        phoneNumber.localNumber.split(""),
+        3,
+        "-"
+      ).join("")}`;
+    },
+    address: (address, inline) => {
+      if (address === void 0) return "no_address";
+      const addressKeys = Object.keys(address).map((k) => k);
+      const delimiter = (isLast) => !isLast ? "," + (!inline ? "\n" : "") : "";
+      return addressKeys.map(
+        (key, idx) => address[key] + delimiter(idx === lastIndex(addressKeys))
+      ).join("") || "no_address";
+    }
+  };
+};
+var ObjectFormatter_default = ObjectFormatter;
+
+// src/helper-functions/HelperFunctions.ts
+var import_uuid = require("uuid");
+var import_types = require("@wavy/types");
+var import_console = require("console");
+var dateFormat = new TimeManager_default().format;
+var timeDuration = new TimeManager_default().getDuration;
+var upperFirst = StringFormatter_default.upperFirst;
+var camelCaseToLetter = StringFormatter_default.caseConverter.camelToLetter;
+var trimString = StringFormatter_default.trimString;
+var stringToSearch = StringFormatter_default.toSearch;
+var getCaps = StringFormatter_default.extract.capitalLetters;
+var toNumber = StringFormatter_default.toNumber;
+var addArticle = StringFormatter_default.addArticle;
+var pluralize = StringFormatter_default.pluralize;
+var objToString = ObjectFormatter_default.toString;
+var nameToString = objToString.name;
+var phoneNoToString = objToString.phoneNumber;
+var addressToString = objToString.address;
+var toMoney = (value, options) => typeof value === "string" ? StringFormatter_default.toMoney(value, options) : NumberFormatter_default.toMoney(value, options);
+function format(event, ...args) {
+  const getCaller = (caller) => {
+    return caller(...args);
+  };
+  switch (event) {
+    case "date":
+      return getCaller(dateFormat);
+    case "address":
+      return getCaller(addressToString);
+    case "money":
+      return getCaller(toMoney);
+    case "name":
+      return getCaller(nameToString);
+    case "phone-number":
+      return getCaller(phoneNoToString);
+    default:
+      return event;
+  }
+}
+function isFile(obj) {
+  const fileKeys = Object.keys({
+    arrayBuffer: null,
+    bytes: null,
+    lastModified: null,
+    name: null,
+    size: null,
+    slice: null,
+    stream: null,
+    text: null,
+    type: null,
+    webkitRelativePath: null
+  });
+  if (obj && typeof obj === "object" && fileKeys.every((key) => key in obj))
+    return true;
+  return false;
+}
+function toObject(object, ...args) {
+  if (isFile(object)) {
+    const options = args[0];
+    const fileName = (() => {
+      const fileExt = getFileExt(object.name);
+      if (options?.filename && options.filename.includes(fileExt))
+        return options.filename;
+      else if (options?.filename) return options.filename.trim() + fileExt;
+      return object.name;
+    })()?.trim?.();
+    return {
+      uid: (0, import_uuid.v4)(),
+      description: options?.description,
+      path: options?.filepath || object.webkitRelativePath,
+      typeAlias: options?.typeAlias || run(
+        Object.keys(import_types.LOCAL_FILE_MIME_TYPES).find(
+          (key) => import_types.LOCAL_FILE_MIME_TYPES[key].includes(object.type)
+        ),
+        (type) => {
+          if (!type) {
+            (0, import_console.log)("An unknown file type was found ", object.type);
+            return "unknown";
+          }
+          return type;
+        }
+      ),
+      sizeInBytes: object.size,
+      uploadDate: options?.uploadDate === "now" ? Date.now() : options?.uploadDate ?? object.lastModified,
+      name: fileName
+    };
+  }
+}
+function classNameResolver(baseClassName) {
+  return (className) => {
+    return `${baseClassName}-${className}`;
+  };
+}
+function classNameExt(rootClassName) {
+  return (className) => {
+    return `${rootClassName} ${className}`;
+  };
+}
+function range(start, end) {
+  return buildArray(end - start, (i) => i + start);
+}
+function lastIndex(value) {
+  return value.length - 1;
+}
+function buildArray(length, func) {
+  return Array.from(Array(length)).map((_, idx) => func(idx));
+}
+function blankSpaces(count2) {
+  return buildArray(count2, () => "\u200C").join(" ");
+}
+function ordinalIndicator(amount) {
+  const stringifiedAmount = `${amount}`;
+  const lastIdx = lastIndex(stringifiedAmount);
+  const lastChar = stringifiedAmount[lastIdx];
+  const secondToLastChar = stringifiedAmount[lastIdx - 1];
+  let indicator;
+  if (secondToLastChar === "1") indicator = "th";
+  else if (lastChar === "1") indicator = "st";
+  else if (lastChar === "2") indicator = "nd";
+  else if (lastChar === "3") indicator = "rd";
+  else indicator = "th";
+  return stringifiedAmount + indicator;
+}
+function indexOf(arr, key, value) {
+  const queriedValue = arr.find((obj) => obj[key] === value);
+  if (!queriedValue) return;
+  return arr.indexOf(queriedValue);
+}
+function formatInvoiceNo(invoiceNo) {
+  return `INV-${invoiceNo}`;
+}
+function formatGCTRegNo(regNo) {
+  return `GCT-${regNo}`;
+}
+function indices(arr) {
+  return arr.map((_, idx) => idx);
+}
+function hasIndex(arr, index) {
+  return indices(arr).includes(index);
+}
+function repeat(count2, func) {
+  for (let idx = 0; idx < count2; idx++) {
+    func(idx);
+  }
+}
+function isLetter(value) {
+  return "abcdefghijklmnopqrstuvwxyz".includes(value.toLowerCase());
+}
+function isNumber(value) {
+  return "0123456789".includes(value);
+}
+function count(searchFor, arrayish) {
+  const fmtArr = typeof arrayish === "string" ? arrayish.split("") : arrayish;
+  return fmtArr.filter((v) => v === searchFor).length;
+}
+function subObjectList(value, array) {
+  const newArray = [];
+  array.forEach((item) => {
+    if (item[value.key] === value.value) {
+      newArray.push(item);
+    }
+  });
+  return newArray;
+}
+function random(max, min) {
+  const randNum = Math.floor(Math.random() * max);
+  return min !== void 0 && randNum < min ? random(max, min) : randNum;
+}
+function undefinedIfEmpty(value) {
+  if (value.length > 0) return value;
+}
+function ifEmpty(value, fallback) {
+  return isEmpty(value) ? fallback : value;
+}
+function windowed(arr, count2) {
+  const newArr = Array.from(
+    Array(Math.floor(arr.length / count2 + arr.length % count2))
+  ).map(() => []);
+  arr.forEach((val, idx) => newArr[Math.floor(idx / count2)]?.push(val));
+  return newArr.filter((arr2) => arr2.length > 0);
+}
+function group(arr, isGroup) {
+  const groups = [];
+  arr.forEach((value) => {
+    const groupIdx = groups.findIndex(
+      (group2) => group2.every((groupVal) => isGroup(value, groupVal))
+    );
+    if (groupIdx !== -1) {
+      groups[groupIdx].push(value);
+    } else {
+      groups[groups.length] = [value];
+    }
+  });
+  return groups;
+}
+function strictArray(arr) {
+  return arr.filter(
+    (val) => typeof val === "string" ? val.trim().length > 0 : val !== void 0 && val !== null
+  );
+}
+function maxOf(arr) {
+  const fmtArr = strictArray(arr);
+  return isEmpty(arr) ? 0 : fmtArr.reduce((prev, current) => current > prev ? current : prev);
+}
+function minOf(arr) {
+  const fmtArr = strictArray(arr);
+  return isEmpty(arr) ? 0 : fmtArr.reduce((prev, current) => current < prev ? current : prev);
+}
+function averageOf(arr) {
+  const fmtArr = strictArray(arr);
+  return isEmpty(fmtArr) ? 0 : sumOf(fmtArr) / fmtArr.length;
+}
+function run(value, fn) {
+  return fn(value);
+}
+async function asyncRun(value, fn) {
+  return fn(value);
+}
+function coerceIn(arr, min, max) {
+  return arr.map((num) => num > max ? max : num < min ? min : num);
+}
+function sort(arr, sortBy, order = "asc") {
+  const queryObj = (obj) => {
+    const value = obj[sortBy];
+    return typeof value === "string" ? value.toLowerCase() : value;
+  };
+  const sortOrder = (a, b) => {
+    const queryA = queryObj(a);
+    const queryB = queryObj(b);
+    if (typeof queryA === "string") {
+      const comparedQuery = queryA.localeCompare(queryB, void 0, {
+        numeric: queryA.split("").some((char) => isNumber(char)),
+        sensitivity: "base"
+      });
+      return order === "asc" ? comparedQuery === -1 : comparedQuery === 1;
+    }
+    return order === "asc" ? queryA < queryB : queryA > queryB;
+  };
+  return arr.toSorted(
+    (a, b) => sortOrder(a, b) ? -1 : queryObj(a) === queryObj(b) ? 0 : 1
+  );
+}
+function sumOf(value) {
+  return !isEmpty(value) ? value.reduce((acc, amt) => acc + amt) : 0;
+}
+function insertAt(arr, index, value) {
+  return arr.toSpliced(index, 0, value);
+}
+function overwrite(arr, index, newValue) {
+  return arr.with(index, newValue);
+}
+function take(value, amount) {
+  return [...value].splice(0, amount);
+}
+function takeWhile(value, fn) {
+  const newValue = [];
+  for (let idx = 0; idx < value.length; idx++) {
+    if (!fn(value[idx], idx)) break;
+    newValue.push(value[idx]);
+  }
+  return newValue;
+}
+function takeLast(arr, amount = 1) {
+  if (amount <= 1) return [arr[arr.length - 1]];
+  return [...arr].splice(arr.length - amount);
+}
+function takeLastWhile(value, fn) {
+  const newValue = [];
+  for (let idx = 0; idx < value.length; idx++) {
+    const lastIdx = value.length - 1 - idx;
+    if (!fn(value[lastIdx], lastIdx)) break;
+    newValue.push(value[lastIdx]);
+  }
+  return newValue.reverse();
+}
+function drop(arr, count2) {
+  return arr.slice(count2 || 1);
+}
+function dropWhile(arr, fn) {
+  return arr.filter((v, idx) => fn(v, idx) ? false : true);
+}
+function dropLast(arr, count2 = 1) {
+  return arr.slice(0, arr.length - count2);
+}
+function dropLastWhile(arr, fn) {
+  return dropWhile(arr.toReversed(), fn).toReversed();
+}
+function dataSearcher(dataSource, queryProperty, searchFor, options) {
+  const toSearch = (value) => stringToSearch(JSON.stringify(value)).replaceAll('"', "");
+  return dataSource.filter((value) => {
+    const propVal = toSearch(value[queryProperty]);
+    const searcher = toSearch(searchFor);
+    return options?.strictEquality ? propVal === searcher : propVal.includes(searcher);
+  });
+}
+function inRange(value, min, max, options) {
+  if (options?.excludeBoth) return value > min && value < max;
+  if (options?.excludeMax) return value >= min && value < max;
+  if (options?.excludeMin) return value > min && value <= max;
+  return value >= min && value <= max;
+}
+function negate(condition, negate2) {
+  return negate2 ? !condition : condition;
+}
+function removeAll(str, remove) {
+  return str.split("").filter((char) => char !== remove).join("");
+}
+function mapToArray(map2) {
+  return map2.entries().toArray().map(([key, value]) => ({ [key]: value }));
+}
+function distinct(arr) {
+  const newArr = [];
+  arr.forEach((value) => {
+    if (!newArr.includes(value)) newArr.push(value);
+  });
+  return newArr;
+}
+function map(from, mappedFields) {
+  return Object.fromEntries(
+    Object.keys(mappedFields).map((key) => {
+      const validKey = key;
+      return [mappedFields[validKey], from[validKey]];
+    })
+  );
+}
+function isEmpty(value) {
+  const valueLength = typeof value === "string" ? value.trim().length : value.length;
+  return valueLength === 0;
+}
+function ifDefined(value, cb) {
+  return !value ? void 0 : cb(value);
+}
+function someValuesEmpty(obj) {
+  return Object.keys(obj).some((key) => isEmpty(obj[key]));
+}
+async function poll(getValue, interval = 100) {
+  while (true) {
+    const value = await getValue();
+    if (value !== void 0) {
+      return value;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+}
+function inferFilename(filePath) {
+  return takeLastWhile(
+    filePath.split(""),
+    (char) => !"/\\".includes(char)
+  ).join("");
+}
+function getFileExt(filePath) {
+  return "." + takeLastWhile(filePath.split(""), (v) => v !== ".").join("");
+}
+async function copyToClipboard(text) {
+  try {
+    await navigator.clipboard.writeText(text);
+    return { data: "success" };
+  } catch (err) {
+    console.error("Failed to copy text: ", err);
+    if (err instanceof Error) {
+      return {
+        error: {
+          errorCode: "UNKNOWN",
+          title: err.name,
+          message: err.message
+        }
+      };
+    }
+    return {
+      error: {
+        errorCode: "UNKNOWN",
+        title: "Failed to copy text",
+        message: JSON.stringify(err)
+      }
+    };
+  }
+}
+async function readClipboardText() {
+  try {
+    const text = await navigator.clipboard.readText();
+    return { data: { text: text.trim() } };
+  } catch (err) {
+    console.error("Failed to read clipboard contents: ", err);
+    return {
+      error: {
+        errorCode: "UNKNOWN",
+        title: "Failed to read clipboard contents",
+        message: `Something went wrong while trying to read the clipboard contents. [CAUSE]: ${JSON.stringify(
+          err
+        )}.`
+      }
+    };
+  }
+}
+function arrayWithConst(array) {
+  return { value: array, asConst: [...array] };
+}
+
+// src/server-adapters/ServerAdapters.ts
+var import_types2 = require("@wavy/types");
+var iiKeys = Object.keys({
+  name: null,
+  address: null,
+  phoneNumber: null
+});
+var stringArrayIdPrefix = "listOf";
+var multiDimArrayIdPrefix = "2DListOf";
+var multiDimArrayDelim = ":";
+var DELIMITERS = {
+  name: " ",
+  address: "|",
+  phoneNumber: " ",
+  stringArray: " "
+};
+var INDEX_MAPPER = {
+  name: { first: 0, last: 1 },
+  address: {
+    streetAddress: 0,
+    city: 1,
+    parish: 2,
+    country: 3
+  },
+  phoneNumber: {
+    countryCode: 0,
+    areaCode: 1,
+    localNumber: 2
+  }
+};
+function zip(data) {
+  const stringifiedData = JSON.stringify(data);
+  const errorMessage = `Failed to execute [${zip.name}].`;
+  return JSON.parse(stringifiedData, (key, value) => {
+    if (iiKeys.includes(key)) {
+      const validKey = key;
+      const handleTypeMismatchError = (required) => {
+        if (typeof required !== typeof value) {
+          throw new Error(errorMessage, {
+            cause: `[Type Mismatch] Property type {${key}:${JSON.stringify(
+              required
+            )}} is required, but {${key}:${JSON.stringify(
+              value
+            )}} was provided.`
+          });
+        }
+      };
+      switch (validKey) {
+        case "name":
+          handleTypeMismatchError({ first: "", last: "" });
+          break;
+        case "address":
+          handleTypeMismatchError({
+            streetAddress: "",
+            city: "",
+            parish: "",
+            country: "Jamaica"
+          });
+          break;
+        case "phoneNumber":
+          handleTypeMismatchError({
+            countryCode: "1",
+            areaCode: "876",
+            localNumber: ""
+          });
+          break;
+        default:
+          return validKey;
+      }
+      let group2 = [];
+      Object.keys(INDEX_MAPPER[validKey]).forEach((prop) => {
+        const validProp = prop;
+        group2[INDEX_MAPPER[validKey][validProp]] = value[validProp]?.trim?.() || "";
+      });
+      return group2.join(DELIMITERS[validKey]).trim();
+    }
+    const valueIsArray = Array.isArray(value);
+    const hasArrayId = key.includes(stringArrayIdPrefix);
+    if (hasArrayId && valueIsArray && strictArray(value).every((v) => typeof v === "string")) {
+      return strictArray(value).join(DELIMITERS.stringArray).trim();
+    } else if (hasArrayId) {
+      throw new Error(errorMessage, {
+        cause: `[Type Mismatch] Every property with the ${stringArrayIdPrefix} prefix, must be an array of strings. However {${key}:${value}} was provided.`
+      });
+    }
+    const hasMultiDimArrayId = key.includes(multiDimArrayIdPrefix);
+    if (hasMultiDimArrayId && valueIsArray && key.includes(multiDimArrayDelim) && value.every(
+      (d) => Array.isArray(d) && d.every((sv) => typeof sv === "object")
+    )) {
+      const mapName = key.split(multiDimArrayDelim)[1];
+      return strictArray(value).map(
+        (objArr) => strictArray(objArr).map((obj) => {
+          if (mapName in obj) {
+            const mapValue = obj[mapName];
+            if (typeof mapValue !== "string") {
+              throw new Error(errorMessage, {
+                cause: `[Type Mismatch] Expected {${mapName}:string} but {${mapName}:${mapValue}} was provided.`
+              });
+            }
+            return mapValue;
+          } else
+            throw new Error(errorMessage, {
+              cause: `[Type Mismatch] Every object in the multi dimensional array must have a property with the name ${mapName}. However ${obj} doesn't adhere to this rule.`
+            });
+        }).join(DELIMITERS.stringArray)
+      );
+    } else if (hasMultiDimArrayId && valueIsArray) {
+      return value.map((arr) => {
+        if (!arr.every((d) => typeof d === "string")) {
+          throw new Error(errorMessage, {
+            cause: `[Type Mismatch] Every sub type of the array must be a string. However ${arr} doesn't comply with this rule.`
+          });
+        }
+        return arr.join(DELIMITERS.stringArray);
+      });
+    } else if (hasMultiDimArrayId) {
+      throw new Error(errorMessage, {
+        cause: `[Type Mismatch] Every property with the ${multiDimArrayIdPrefix} prefix, must be a multi dimensional array of strings. However {${key}:${value}} was provided.`
+      });
+    }
+    if (typeof value === "string") return value.trim();
+    return value;
+  });
+}
+function unzip(data) {
+  const stringifiedData = JSON.stringify(data);
+  const errorMessage = `Failed to execute [${unzip.name}]`;
+  return JSON.parse(stringifiedData, (key, value) => {
+    const isIIKey = iiKeys.includes(key);
+    if (isIIKey && typeof value === "string") {
+      const validKey = key;
+      const splitProp = value.split(DELIMITERS[validKey]);
+      return Object.fromEntries(
+        Object.entries(INDEX_MAPPER[validKey]).map(([mapperKey, idx]) => {
+          return [mapperKey, splitProp[idx]?.trim?.() || ""];
+        })
+      );
+    } else if (isIIKey) {
+      throw new Error(errorMessage, {
+        cause: `[Type Mismatch] {${key}:string} expected, but {${key}:${value}} was provided.`
+      });
+    }
+    const hasArrayId = key.includes(stringArrayIdPrefix);
+    if (hasArrayId && typeof value === "string") {
+      return strictArray(value.split(DELIMITERS.stringArray));
+    } else if (hasArrayId) {
+      throw new Error(errorMessage, {
+        cause: `[Type Mismatch] {${key}:string} is required but {${key}:${value}} was provided.`
+      });
+    }
+    const hasMultiDimArrayId = key.includes(multiDimArrayIdPrefix);
+    if (hasMultiDimArrayId && Array.isArray(value)) {
+      const mapName = key.split(multiDimArrayDelim)?.[1];
+      return strictArray(value).map((delimString) => {
+        const splitStr = strictArray(delimString.split(DELIMITERS.stringArray));
+        if (!splitStr.every((d) => typeof d === "string"))
+          throw new Error(errorMessage, {
+            cause: `[Type Mismatch] Expected string[] but found ${splitStr}.`
+          });
+        if (mapName) return splitStr.map((value2) => ({ [mapName]: value2 }));
+        return splitStr;
+      });
+    } else if (hasMultiDimArrayId) {
+      throw new Error(errorMessage, {
+        cause: `[Type Mismatch] {${key}:string[]} is required but {${key}:${value}} was provided.`
+      });
+    }
+    return value;
+  });
+}
+var EVENTS = ["zip", "unzip"];
+var ServerDataAdapter = class {
+  invoke(event, data) {
+    switch (event) {
+      case "unzip":
+        return unzip(data);
+      case "zip":
+        return zip(data);
+      default:
+        event;
+        throw new Error(
+          `"${event}" is an unrecognized event. Try again using one of the following events ${EVENTS}.`
+        );
+    }
+  }
+};
+var serverDataAdapter = new ServerDataAdapter().invoke;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addArticle,
+  arrayWithConst,
+  asyncRun,
+  averageOf,
+  blankSpaces,
+  buildArray,
+  camelCaseToLetter,
+  classNameExt,
+  classNameResolver,
+  coerceIn,
+  copyToClipboard,
+  count,
+  dataSearcher,
+  distinct,
+  drop,
+  dropLast,
+  dropLastWhile,
+  dropWhile,
+  format,
+  formatGCTRegNo,
+  formatInvoiceNo,
+  getCaps,
+  getFileExt,
+  group,
+  hasIndex,
+  ifDefined,
+  ifEmpty,
+  inRange,
+  indexOf,
+  indices,
+  inferFilename,
+  insertAt,
+  isEmpty,
+  isFile,
+  isLetter,
+  isNumber,
+  lastIndex,
+  map,
+  mapToArray,
+  maxOf,
+  minOf,
+  negate,
+  ordinalIndicator,
+  overwrite,
+  pluralize,
+  poll,
+  random,
+  range,
+  readClipboardText,
+  removeAll,
+  repeat,
+  run,
+  serverDataAdapter,
+  someValuesEmpty,
+  sort,
+  strictArray,
+  stringToSearch,
+  subObjectList,
+  sumOf,
+  take,
+  takeLast,
+  takeLastWhile,
+  takeWhile,
+  timeDuration,
+  toNumber,
+  toObject,
+  trimString,
+  undefinedIfEmpty,
+  upperFirst,
+  windowed
+});