@applicaster/zapp-react-native-utils/manifestUtils/_internals.js

Applicaster Zapp React Native utilities package

const R = require("ramda");
const camelize = require("camelize");
const { defaultConfigurations } = require("./defaultManifestConfigurations");

const toSnakeCase = R.compose(R.replace(/\s/g, "_"), R.toLower, R.trim);

const compact = R.reject(R.isNil);

const PLATFORMS = [
  "iOS",
  "Android",
  "Android TV",
  "LG",
  "tvOS",
  "Samsung",
  "Roku",
  "Amazon",
];

const toCamelCase = R.compose(
  camelize,
  R.toLower,
  R.replace(/\s/g, "_"),
  R.trim
);

const replaceUnderscoreToSpace = R.compose(R.replace(/_/g, " "), R.trim);

const capitalize = (value) => {
  if (value) {
    const words = value.split(" ");

    return words
      .map((word) => {
        if (PLATFORMS.includes(word)) return word;

        const letters = word.split("");

        return [R.head(letters).toUpperCase(), ...R.tail(letters)].join("");
      })
      .join(" ");
  }

  return value;
};

const capitalizeFirstLetter = (value) => {
  if (value) {
    const letters = value.split("").map((letter) => letter.toLowerCase());

    return [R.head(letters).toUpperCase(), ...R.tail(letters)].join("");
  }

  return value;
};

const isDefined = (value) => typeof value !== "undefined";

function getConditionalField(label, defaults, prefix = "") {
  const keyName = R.compose(toSnakeCase, R.toLower)(label);

  const hasEnableFlag = isDefined(defaults.enable);
  let conditionalField = {};
  const fields = [];

  if (hasEnableFlag) {
    const switchKeyName = `${keyName}_toggle`;

    fields.push({
      type: "switch",
      label: `Enable ${label}`,
      key: switchKeyName,
      initial_value: defaults.enable,
    });

    conditionalField = {
      conditional_fields: [
        {
          key: `${prefix}${switchKeyName}`,
          condition_value: true,
        },
      ],
    };
  }

  return { fields, conditionalField };
}

function generateFieldsFromDefaults(label, defaults, fields) {
  const keyPrefix = toSnakeCase(label);

  return R.compose(
    R.reject(R.isNil),
    R.map((field) => {
      // eslint-disable-next-line unused-imports/no-unused-vars
      const { suffix, conditions, ...fieldProps } = field;
      const defaultKey = toCamelCase(field.suffix);

      const fieldKey = field.suffix === "enable" ? "switch" : field.suffix;

      if (isDefined(defaults[defaultKey])) {
        const generatedField = {
          ...fieldProps,
          label: !R.isNil(field.label)
            ? capitalize(field.label)
            : capitalize(field.suffix),
          key: `${keyPrefix}_${toSnakeCase(fieldKey)}`,
          initial_value: defaults[defaultKey],
        };

        if (field.tooltip) {
          generatedField.label_tooltip = field.tooltip;
        }

        if (conditions) {
          generatedField.conditional_fields = conditions.map((condition) => {
            const section = condition.section ? `${condition.section}/` : "";

            return {
              key: `${section}${keyPrefix}_${toSnakeCase(condition.key)}`,
              condition_value: condition.value,
            };
          });
        }

        return generatedField;
      }

      return null;
    })
  )(fields);
}

function generateFieldsFromDefaultsWithoutPrefixedLabel(
  label,
  defaults,
  fields
) {
  const keyPrefix = toSnakeCase(label);

  return R.compose(
    R.reject(R.isNil),
    R.map((field) => {
      const { suffix, conditions, ...fieldProps } = field;
      const defaultKey = toCamelCase(suffix);

      if (isDefined(defaults[defaultKey])) {
        const initialValue = defaults[defaultKey];

        const generatedField = {
          ...fieldProps,
          label: capitalizeFirstLetter(field.suffix),
          key: `${keyPrefix}_${toSnakeCase(field.suffix)}`,
          initial_value: R.when(R.is(Array), R.head)(initialValue),
        };

        if (conditions) {
          generatedField.conditional_fields = conditions.map((condition) => {
            const section = condition.section ? `${condition.section}/` : "";

            return {
              key: `${section}${keyPrefix}_${toSnakeCase(condition.key)}`,
              condition_value: condition.value,
            };
          });
        }

        return generatedField;
      }

      return null;
    })
  )(fields);
}

/**
 * returns default configuration keys for provided plugin type
 * @param {('general-content'|'player')} pluginType
 * @param options manifest generator information
 * @param {string} options.version manifest version
 * @param {string} options.platform qb platform value
 */
function getDefaultConfiguration(pluginType, options) {
  const defConfig = R.compose(
    R.unless(R.isNil, (fn) => fn(options)),
    R.propOr(null, pluginType)
  )(defaultConfigurations);

  if (!defConfig) {
    const availableKeys = R.keys(defaultConfigurations);

    const message = `Requested key "${pluginType}" doesn't exist in the default configuration\nAvailable keys: ${availableKeys}`;
    // eslint-disable-next-line no-console
    console.warn(message);
  }

  return defConfig;
}

module.exports = {
  toSnakeCase,
  toCamelCase,
  getConditionalField,
  generateFieldsFromDefaults,
  generateFieldsFromDefaultsWithoutPrefixedLabel,
  isDefined,
  capitalize,
  getDefaultConfiguration,
  compact,
  replaceUnderscoreToSpace,
};