TypeScript react.i18nMark函数代码示例

 args.forEach((arg, index) => {
   if (arg === "" || arg == undefined) {
     errors.push({
       path: ["job", "run", "args", `${index}`],
       message: i18nMark("Arg cannot be empty.")
     });
   }
 });

export function validateFormLabels(jobSpec: JobSpec): FormError[] {
  const labels = (jobSpec.job.labels || []).map(([k]) => k);
  const message = i18nMark("Cannot have multiple labels with the same key.");

  return pipe(
    allUniq(_ => "job.labels", [labels], message),
    isUniqIn(labels)(i => `job.labels.${i}`, labels, message)
  )([]);
}

export function formatServicePlanStatus(status: ServicePlanStatus): string {
  switch (status) {
    case "ERROR":
      return i18nMark("Error");
    case "WAITING":
      return i18nMark("Waiting");
    case "PENDING":
      return i18nMark("Pending");
    case "PREPARED":
      return i18nMark("Prepared");
    case "STARTING":
      return i18nMark("Starting");
    case "STARTED":
      return i18nMark("Started");
    case "COMPLETE":
      return i18nMark("Complete");
    case "IN_PROGRESS":
      return i18nMark("In Progress");
  }
}

function toCategoryLabel(category: StatusCategory): string {
  switch (category) {
    case StatusCategory.NA:
      return i18nMark("N/A");
    case StatusCategory.STOPPED:
      return i18nMark("Stopped");
    case StatusCategory.RUNNING:
      return i18nMark("Running");
    case StatusCategory.LOADING:
      return i18nMark("Processing");
    case StatusCategory.WARNING:
      return i18nMark("Warning");
    case StatusCategory.ERROR:
      return i18nMark("Error");
  }
}

  isValid: (val: T) => boolean,
  defaultMessage: string
) => (path: (i: number) => string, values: T[], message = defaultMessage) => (
  errors: FormError[]
) =>
  errors.concat(
    flatMap(
      (value, index) =>
        isValid(value) ? [] : [{ message, path: path(index).split(".") }],
      values
    )
  );

const isBoolean = validation<boolean | undefined>(
  x => x === undefined || typeof x === "boolean",
  i18nMark("Must be a boolean.")
);
const isNumber = validation<number | undefined>(
  x => x === undefined || typeof x === "number",
  i18nMark("Must be a number.")
);
const isObject = validation<object | undefined>(
  x => x === undefined || isObjectUtil(x),
  i18nMark("Must be an object.")
);
const isPresent = validation<any>(
  x => x !== undefined && x !== "",
  i18nMark("Must be present.")
);
const isString = validation<string | undefined>(
  x => x === undefined || typeof x === "string",

  ERROR = "ERROR"
}

interface Status {
  displayName: string;
  category: StatusCategory;
  priority: number;
}

///////////////////////////////////////////////////////////////////////////////
//                                   ERRORS                                 //
///////////////////////////////////////////////////////////////////////////////

const CREATION_ERROR: Status = {
  priority: 32,
  displayName: i18nMark("Error Creating Service"),
  category: StatusCategory.ERROR
};
const UNAVAILABLE = {
  priority: 31,
  displayName: i18nMark("Service Unavailable"),
  category: StatusCategory.ERROR
};
const ERROR = {
  priority: 30,
  displayName: i18nMark("Error"),
  category: StatusCategory.ERROR
};

///////////////////////////////////////////////////////////////////////////////
//                                 WARNINGS                                  //

import { i18nMark } from "@lingui/react";

interface ServiceActionLabelsInterface {
  edit: string;
  delete: string;
  restart: string;
  resume: string;
  open: string;
  scale: string;
  scale_by: string;
  stop: string;
}

const ServiceActionLabels: ServiceActionLabelsInterface = {
  edit: i18nMark("Edit"),
  delete: i18nMark("Delete"),
  restart: i18nMark("Restart"),
  resume: i18nMark("Resume"),
  open: i18nMark("Open Service"),
  scale: i18nMark("Scale"),
  scale_by: i18nMark("Scale By"),
  stop: i18nMark("Stop")
};

export default ServiceActionLabels;