discourse-custom-wizard/assets/javascripts/discourse/lib/wizard-mapper.js.es6

import EmberObject from "@ember/object";
import { A } from "@ember/array";
import I18n from "I18n";

// Inputs

const selectableInputTypes = [
  "conditional",
  "assignment",
  "association",
  "validation",
];

function defaultInputType(options = {}) {
  return options.inputTypes.split(",")[0];
}

function mapInputTypes(types) {
  return types.map(function (type) {
    return {
      id: type,
      name: I18n.t(`admin.wizard.input.${type}.name`),
    };
  });
}

function inputTypesContent(options = {}) {
  return options.inputTypes
    ? mapInputTypes(options.inputTypes.split(","))
    : mapInputTypes(selectableInputTypes);
}

// connectorTypes

const connectors = {
  pair: [
    "equal",
    "not_equal",
    "greater",
    "less",
    "greater_or_equal",
    "less_or_equal",
    "regex",
    "is",
  ],
  output: ["then", "set"],
};

function defaultConnector(connectorType, inputType, options = {}) {
  if (connectorType === "input") {
    return defaultInputType(options);
  }
  if (connectorType === "pair") {
    if (inputType === "conditional") {
      return "equal";
    }
    if (inputType === "association") {
      return "association";
    }
    if (inputType === "validation") {
      return "equal";
    }
  }
  if (connectorType === "output") {
    if (inputType === "conditional") {
      return "then";
    }
    if (inputType === "assignment") {
      return "set";
    }
  }
  return "equal";
}

function connectorContent(connectorType, inputType, opts) {
  let connector = opts[`${connectorType}Connector`];

  if (
    (!connector && connectorType === "output") ||
    inputType === "association"
  ) {
    connector = defaultConnector(connectorType, inputType);
  }

  let content = connector ? [connector] : connectors[connectorType];

  return content.map(function (item) {
    return {
      id: item,
      name: I18n.t(`admin.wizard.connector.${item}`),
    };
  });
}

// Selectors

const selectionTypes = [
  "text",
  "list",
  "wizardField",
  "wizardAction",
  "userField",
  "userFieldOptions",
  "group",
  "category",
  "tag",
  "user",
  "customField",
  "value",
];

function defaultSelectionType(inputType, options = {}, connector = null) {
  if (options[`${inputType}DefaultSelection`]) {
    return options[`${inputType}DefaultSelection`];
  }

  if (connector === "is") {
    return "value";
  }

  let type = selectionTypes[0];

  for (let t of selectionTypes) {
    let inputTypes = options[`${t}Selection`];

    if (
      inputTypes === true ||
      (typeof inputTypes === "string" &&
        inputTypes.split(",").indexOf(inputType) > -1)
    ) {
      type = t;
      break;
    }
  }

  return type;
}

// items

function newPair(inputType, options = {}) {
  let params = {
    index: options.index,
    pairCount: options.pairCount,
    key: "",
    key_type: defaultSelectionType("key", options),
    value: "",
    value_type: defaultSelectionType("value", options),
    connector: defaultConnector("pair", inputType, options),
  };

  return EmberObject.create(params);
}

function newInput(options = {}, count) {
  const inputType = defaultInputType(options);

  let params = {
    type: inputType,
    pairs: A([
      newPair(
        inputType,
        Object.assign({}, options, { index: 0, pairCount: 1 })
      ),
    ]),
  };

  if (count > 0) {
    params.connector = options.inputConnector;
  }

  if (
    ["conditional", "assignment"].indexOf(inputType) > -1 ||
    options.outputDefaultSelection ||
    options.outputConnector
  ) {
    params["output_type"] = defaultSelectionType("output", options);
    params["output_connector"] = defaultConnector("output", inputType, options);
  }

  return EmberObject.create(params);
}

export {
  defaultInputType,
  defaultSelectionType,
  defaultConnector,
  connectorContent,
  inputTypesContent,
  selectionTypes,
  newInput,
  newPair,
};