@openmrs/esm-config 4.0.0-pre.0 → 4.0.0-pre.1

package/src/navigation/interpolate-string.test.ts

@@ -15,14 +15,14 @@ describe("interpolateUrl", () => {
 describe("interpolateString", () => {
   it("interpolates template elements", () => {
     const result = interpolateString("test ${one} ${two} 3", {
-      one: 1,
-      two: 2,
+      one: "1",
+      two: "2",
     });
     expect(result).toBe("test 1 2 3");
   });
 
   it("tolerates extra parameters", () => {
-    const result = interpolateString("test ok", { one: 1, two: 2 });
+    const result = interpolateString("test ok", { one: "1", two: "2" });
     expect(result).toBe("test ok");
   });
 });

package/src/navigation/interpolate-string.ts

@@ -11,12 +11,17 @@ function trimTrailingSlash(str: string) {
  * parameters in configurable URLs.
  *
  * @param template A string to interpolate
+ * @param additionalParams Additional values to interpolate into the string template
  */
-export function interpolateUrl(template: string): string {
+export function interpolateUrl(
+  template: string,
+  additionalParams?: { [key: string]: string }
+): string {
   const openmrsSpaBase = trimTrailingSlash(window.getOpenmrsSpaBase());
   return interpolateString(template, {
     openmrsBase: window.openmrsBase,
     openmrsSpaBase: openmrsSpaBase,
+    ...additionalParams,
   }).replace(/^\/\//, "/"); // remove extra initial slash if present
 }
 
@@ -38,7 +43,10 @@ export function interpolateUrl(template: string): string {
  * @param template With optional params wrapped in `${ }`
  * @param params Values to interpolate into the string template
  */
-export function interpolateString(template: string, params: object): string {
+export function interpolateString(
+  template: string,
+  params: { [key: string]: string }
+): string {
   const names = Object.keys(params);
   return names.reduce(
     (prev, curr) => prev.split("${" + curr + "}").join(params[curr]),

package/src/navigation/navigate.ts

@@ -7,8 +7,11 @@ function trimTrailingSlash(str: string) {
   return str.replace(/\/$/, "");
 }
 
+export type TemplateParams = { [key: string]: string };
+
 export interface NavigateOptions {
   to: string;
+  templateParams?: TemplateParams;
 }
 
 /**
@@ -16,19 +19,22 @@ export interface NavigateOptions {
  *
  * Example usage:
  * ```js
- * const config = getConfig();
+ * const config = useConfig();
  * const submitHandler = () => {
  *   navigate({ to: config.links.submitSuccess });
  * };
  * ```
  *
- * @param to The target path or URL. Supports templating with 'openmrsBase' and 'openmrsSpaBase'.
+ * @param to The target path or URL. Supports templating with 'openmrsBase', 'openmrsSpaBase',
+ * and any additional template parameters defined in `templateParams`.
  * For example, `${openmrsSpaBase}/home` will resolve to `/openmrs/spa/home`
  * for implementations using the standard OpenMRS and SPA base paths.
+ * If `templateParams` contains `{ foo: "bar" }`, then the URL `${openmrsBase}/${foo}`
+ * will become `/openmrs/bar`.
  */
-export function navigate({ to }: NavigateOptions): void {
+export function navigate({ to, templateParams }: NavigateOptions): void {
   const openmrsSpaBase = trimTrailingSlash(window.getOpenmrsSpaBase());
-  const target = interpolateUrl(to);
+  const target = interpolateUrl(to, templateParams);
   const isSpaPath = target.startsWith(openmrsSpaBase);
 
   if (isSpaPath) {

package/src/validators/validator.ts

@@ -1,13 +1,38 @@
 /** @module @category Config Validation */
 import { Validator, ValidatorFunction } from "../types";
 
+/**
+ * Constructs a custom validator.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * {
+ *   foo: {
+ *     _default: 0,
+ *     _validators: [
+ *       validator(val => val >= 0, "Must not be negative.")
+ *     ]
+ *   }
+ * }
+ * ```
+ * @param validationFunction Takes the configured value as input. Returns true
+ *    if it is valid, false otherwise.
+ * @param message A string message that explains why the value is invalid. Can
+ *    also be a function that takes the value as input and returns a string.
+ * @returns A validator ready for use in a config schema
+ */
 export function validator(
   validationFunction: ValidatorFunction,
-  message: string
+  message: string | ((value: any) => string)
 ): Validator {
   return (value) => {
     if (!validationFunction(value)) {
-      return message;
+      if (typeof message === "function") {
+        return message(value);
+      } else {
+        return message;
+      }
     }
   };
 }

package/src/validators/validators.test.ts

@@ -1,9 +1,16 @@
-import { isUrl, isUrlWithTemplateParameters } from "./validators";
+import {
+  inRange,
+  isUrl,
+  isUrlWithTemplateParameters,
+  oneOf,
+} from "./validators";
 
 describe("all validators", () => {
   it("fail on undefined", () => {
+    expect(inRange(0, 10)(undefined)).toMatch(/.*/);
     expect(isUrl(undefined)).toMatch(/.*/);
     expect(isUrlWithTemplateParameters(["foo"])(undefined)).toMatch(/.*/);
+    expect(oneOf(["foo", "bar"])(undefined)).toMatch(/.*/);
   });
 });
 
@@ -22,3 +29,13 @@ describe("isUrl", () => {
     );
   });
 });
+
+describe("oneOf", () => {
+  it("accepts one of the valid options", () => {
+    expect(oneOf(["foo", "bar"])("foo")).toBeUndefined();
+  });
+
+  it("rejects anything else", () => {
+    expect(oneOf(["foo", "bar"])("baz")).toMatch(/one of.*foo.*bar/i);
+  });
+});

package/src/validators/validators.ts

@@ -45,7 +45,7 @@ export const isUrlWithTemplateParameters = (
     }
 
     return true;
-  }, "should be a URL or path. The allowed template parameters are " + allowedParams.map((p) => "${" + p + "}").join(", "));
+  }, "Should be a URL or path. The allowed template parameters are " + allowedParams.map((p) => "${" + p + "}").join(", "));
 };
 
 /**
@@ -55,8 +55,20 @@ export const isUrlWithTemplateParameters = (
  */
 export const isUrl = isUrlWithTemplateParameters([]);
 
+/**
+ * Verifies that the value is one of the allowed options.
+ * @param allowedValues The list of allowable values
+ */
+export const oneOf = (allowedValues: Array<any>) => {
+  return validator(
+    (val) => allowedValues.includes(val),
+    `Must be one of the following: '${allowedValues.join("', '")}'.`
+  );
+};
+
 export const validators = {
   inRange,
   isUrl,
   isUrlWithTemplateParameters,
+  oneOf,
 };