@applicaster/zapp-react-native-utils/stringUtils/index.ts

Applicaster Zapp React Native utilities package

declare const Buffer;
declare const global;

import * as R from "ramda";
import camelize from "camelize";
// @ts-ignore
import Handlebars from "react-native-handlebars";

global.Buffer = global.Buffer || require("buffer").Buffer;

/**
 * sets the first letter of the string as uppercase
 * @param {String} string to capitalize
 * @return {String} capitalized string
 */
export const capitalize: (string) => string = R.compose(
  R.join(""),
  R.juxt([R.compose(R.toUpper, R.head), R.tail])
);

export const toCamelCase = camelize;

/**
 * transforms a string from snake_case to PascalCase
 * @param {String} string to be transformed
 * @return {String} transformed string
 */
export const toPascalCase: (string) => string = R.compose(capitalize, camelize);

/**
 * transforms a string to base 64
 * @param {string} string to be converted
 * @return {string} base64 string
 */
export function to64(string) {
  return Buffer.from(string).toString("base64");
}

/**
 * transforms a string from base 64
 * @param {string} string base 64 base string to convert
 * @return {string}
 */
export function from64(string) {
  return Buffer.from(string, "base64").toString();
}

/**
 * create random uuid
 * @return {string}
 */
export function createUUID() {
  var dt = new Date().getTime();
  var uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
    /[xy]/g,
    function (c) {
      var r = (dt + Math.random() * 16) % 16 | 0;
      dt = Math.floor(dt / 16);

      return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
    }
  );

  return uuid;
}

const replaceSeparator = (initial, final) =>
  R.replace(new RegExp(initial, "g"), final);

const valueIsNull = (value) => () => value === null;

const encodeHelper = "encodeURL";

const encodeHandlebarsExpressions = R.compose(
  R.replace(/{{([^}]+)}}/g, (match, p1) =>
    p1.includes("search") ? match : `{{{${encodeHelper} ${p1}}}}`
  )
);

type SeparatorsType = {
  start: string;
  end: string;
};

type InflateUrlArgs = {
  string: string;
  separators?: Nullable<SeparatorsType>;
  data: Nullable<Record<string, unknown>>;
};

/**
 * this function will inflate a string with values coming from an object
 * @param {Object} options
 * @param {String} options.string template to inflate
 * @param {Object} options.data to inject in the template
 * @param {Object=} options.separators optional object defining custom separators to use
 * @param {String} options.separators.start
 * @param {String} options.separators.end
 *
 * @returns {string}
 */
export function inflateString({
  string = "",
  separators = null,
  data = null,
}: InflateUrlArgs): string | null {
  if (!data) {
    return null;
  }

  const handlebarsSeparators = {
    start: "{{",
    end: "}}",
  };

  const template = R.unless(
    valueIsNull(separators),
    R.compose(
      replaceSeparator(separators?.start, handlebarsSeparators.start),
      replaceSeparator(separators?.end, handlebarsSeparators.end)
    )
  )(string);

  Handlebars.registerHelper(encodeHelper, (str) => {
    return str ? encodeURIComponent(str) : "";
  });

  const inflater = Handlebars.compile(encodeHandlebarsExpressions(template));

  return inflater(data);
}

export function objectToReadableString(
  object: { [key: string]: string },
  separator: string = "\r\n"
): string {
  return Object.keys(object)
    .map((key) => `${key}: ${object[key]}`)
    .join(separator);
}

export function objectToCamelCase(obj) {
  const newObj = {};

  Object.keys(obj).forEach((key) =>
    Object.assign(newObj, { [toCamelCase(key)]: obj[key] })
  );

  return newObj;
}

export function isString(value: unknown): value is string {
  return typeof value === "string" || value instanceof String;
}

/** Checks if a value is a non-empty string */
export function isNotEmptyString(value: unknown): value is string {
  return isString(value) && value.length > 0;
}