@player-ui/common-expressions-plugin 0.7.4-next.4 → 0.7.5--canary.434.14868

package/package.json

@@ -1,67 +1,33 @@
 {
   "name": "@player-ui/common-expressions-plugin",
-  "version": "0.7.4-next.4",
-  "private": false,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
+  "version": "0.7.5--canary.434.14868",
+  "main": "dist/cjs/index.cjs",
   "peerDependencies": {
-    "@player-ui/player": "0.7.4-next.4"
+    "@player-ui/player": "0.7.5--canary.434.14868"
+  },
+  "devDependencies": {
+    "@player-ui/make-flow": "workspace:*"
   },
   "dependencies": {
-    "@player-ui/expression-plugin": "0.7.4-next.4",
-    "@babel/runtime": "7.15.4"
+    "@player-ui/expression-plugin": "0.7.5--canary.434.14868",
+    "tslib": "^2.6.2"
   },
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "typings": "dist/index.d.ts",
+  "module": "dist/index.legacy-esm.js",
+  "types": "types/index.d.ts",
+  "bundle": "dist/CommonExpressionsPlugin.native.js",
   "sideEffects": false,
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/player-ui/player-ui"
-  },
-  "bugs": {
-    "url": "https://github.com/player-ui/player-ui/issues"
-  },
-  "homepage": "https://player-ui.github.io",
-  "contributors": [
-    {
-      "name": "Adam Dierkens",
-      "url": "https://github.com/adierkens"
-    },
-    {
-      "name": "Spencer Hamm",
-      "url": "https://github.com/spentacular"
-    },
-    {
-      "name": "Harris Borawski",
-      "url": "https://github.com/hborawski"
-    },
-    {
-      "name": "Jeremiah Zucker",
-      "url": "https://github.com/sugarmanz"
-    },
-    {
-      "name": "Ketan Reddy",
-      "url": "https://github.com/KetanReddy"
-    },
-    {
-      "name": "Brocollie08",
-      "url": "https://github.com/brocollie08"
-    },
-    {
-      "name": "Kelly Harrop",
-      "url": "https://github.com/kharrop"
-    },
-    {
-      "name": "Alejandro Fimbres",
-      "url": "https://github.com/lexfm"
-    },
-    {
-      "name": "Rafael Campos",
-      "url": "https://github.com/rafbcampos"
+  "exports": {
+    "./package.json": "./package.json",
+    "./dist/index.css": "./dist/index.css",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/cjs/index.cjs"
     }
-  ],
-  "bundle": "./dist/common-expressions-plugin.prod.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ]
 }

package/src/expressions/__tests__/expressions.test.ts

@@ -0,0 +1,373 @@
+import { describe, expect, it, test, beforeEach } from "vitest";
+import type { ExpressionContext, DataModelWithParser } from "@player-ui/player";
+import { BindingParser, LocalModel, withParser } from "@player-ui/player";
+import {
+  size,
+  concat,
+  round,
+  floor,
+  ceil,
+  trim,
+  upperCase,
+  lowerCase,
+  replace,
+  titleCase,
+  sentenceCase,
+  isEmpty,
+  isNotEmpty,
+  findProperty,
+  findPropertyIndex,
+  sum,
+  containsAny,
+} from "..";
+
+const parseBinding = new BindingParser().parse;
+describe("expr functions", () => {
+  let model: DataModelWithParser;
+  let context: ExpressionContext;
+
+  beforeEach(() => {
+    model = withParser(new LocalModel(), parseBinding);
+    context = {
+      model,
+      evaluate: () => undefined,
+    };
+  });
+
+  describe("replace", () => {
+    test("works on simple things", () => {
+      expect(replace(context, "foo-bar-baz", "bar-", "")).toBe("foo-baz");
+      expect(replace(context, "adam #1", "1", "2")).toBe("adam #2");
+    });
+
+    test("replaces all occurrences", () => {
+      expect(replace(context, "B1 B2 B3 B4", "B", "A")).toBe("A1 A2 A3 A4");
+    });
+
+    test("leaves non-string things alone", () => {
+      expect(replace(context, 2, "foo", "bar")).toBe(2);
+      expect(replace(context, undefined, undefined)).toBe(undefined);
+      expect(replace(context, "foo", undefined)).toBe("foo");
+    });
+
+    test("defaults to empty replacement", () => {
+      expect(replace(context, "foo", "o")).toBe("f");
+    });
+  });
+
+  describe("math", () => {
+    it("works for rounding", () => {
+      expect(round(context, "1.5")).toBe(2);
+      expect(round(context, 1.5)).toBe(2);
+      expect(round(context, "-1.7")).toBe(-2);
+      expect(round(context, -1.7)).toBe(-2);
+      expect(round(context, undefined as any)).toBe(0);
+    });
+
+    it("works for ceil", () => {
+      expect(ceil(context, "1.5")).toBe(2);
+      expect(ceil(context, 1.3)).toBe(2);
+    });
+
+    it("works for floor", () => {
+      expect(floor(context, "1.5")).toBe(1);
+      expect(floor(context, 1.3)).toBe(1);
+    });
+
+    it("works for sum", () => {
+      expect(sum(context, 1, 2, 3)).toBe(1 + 2 + 3);
+      expect(sum(context, "1", 2, "3")).toBe(1 + 2 + 3);
+    });
+  });
+
+  describe("strings", () => {
+    test("trim", () => {
+      expect(trim(context, "   foo   ")).toBe("foo");
+      expect(trim(context, 123)).toBe(123);
+    });
+
+    test("upperCase", () => {
+      expect(upperCase(context, "foo bar")).toBe("FOO BAR");
+    });
+
+    test("lowerCase", () => {
+      expect(lowerCase(context, "FOO BaR")).toBe("foo bar");
+    });
+
+    test("titleCase", () => {
+      expect(titleCase(context, "foo bar Baz")).toBe("Foo Bar Baz");
+    });
+
+    test("sentenceCase", () => {
+      expect(sentenceCase(context, "foo Bar baz")).toBe("Foo Bar baz");
+    });
+  });
+
+  describe("size", () => {
+    test("good things", () => {
+      expect(size(context, "foo")).toBe(3);
+      expect(size(context, [1, 2, 3, 4])).toBe(4);
+      expect(size(context, { foo: "bar", baz: "blah" })).toBe(2);
+    });
+
+    test("bad things", () => {
+      expect(size(context, null)).toBe(0);
+      expect(size(context, undefined)).toBe(0);
+      expect(size(context, 12)).toBe(0);
+    });
+  });
+
+  describe("concat", () => {
+    test("strings", () => {
+      expect(concat(context, "1")).toBe("1");
+      expect(concat(context, "1", 1)).toBe("11");
+      expect(concat(context, 1, 1)).toBe("11");
+      expect(concat(context, "1", "2", "3")).toBe("123");
+      expect(concat(context, 1, undefined)).toBe("1");
+      expect(concat(context, 0, 1, undefined)).toBe("01");
+    });
+
+    test("arrays", () => {
+      expect(concat(context, [1, 2], [3, 4])).toStrictEqual([1, 2, 3, 4]);
+    });
+  });
+
+  describe("isNotEmpty", () => {
+    test("isNotEmpty", () => {
+      expect(isNotEmpty(context, "")).toBe(false);
+      expect(isNotEmpty(context, undefined)).toBe(false);
+      expect(isNotEmpty(context, null)).toBe(false);
+      expect(isNotEmpty(context, "foo")).toBe(true);
+      expect(isNotEmpty(context, 12)).toBe(true);
+      expect(isNotEmpty(context, [])).toBe(false);
+      expect(isNotEmpty(context, [100])).toBe(true);
+      expect(isNotEmpty(context, [{ foo: "bar" }, { foo: "bar1" }])).toBe(true);
+      expect(isNotEmpty(context, {})).toBe(false);
+      expect(isNotEmpty(context, { foo: "bar" })).toBe(true);
+      // eslint-disable-next-line prefer-const
+      let dummy;
+      expect(isNotEmpty(context, dummy)).toBe(false);
+      dummy = { key: "1" };
+      expect(isNotEmpty(context, dummy)).toBe(true);
+      expect(isNotEmpty(context, dummy.key)).toBe(true);
+    });
+  });
+
+  test("isEmpty", () => {
+    expect(isEmpty(context, "")).toBe(true);
+    expect(isEmpty(context, undefined)).toBe(true);
+    expect(isEmpty(context, null)).toBe(true);
+    expect(isEmpty(context, "foo")).toBe(false);
+    expect(isEmpty(context, 12)).toBe(false);
+    expect(isEmpty(context, [])).toBe(true);
+    expect(isEmpty(context, [100])).toBe(false);
+    expect(isEmpty(context, [{ foo: "bar" }, { foo: "bar1" }])).toBe(false);
+    expect(isEmpty(context, {})).toBe(true);
+    expect(isEmpty(context, { foo: "bar" })).toBe(false);
+    expect(isEmpty(context, undefined)).toBe(true);
+    const dummy = { key: "1" };
+    expect(isEmpty(context, dummy)).toBe(false);
+    expect(isEmpty(context, dummy.key)).toBe(false);
+  });
+
+  describe("findProperty", () => {
+    beforeEach(() => {
+      model.set([
+        [
+          "people",
+          [
+            {
+              name: "Adam",
+              pet: "dog",
+            },
+            {
+              name: "Frodo",
+              pet: "cat",
+            },
+          ],
+        ],
+        ["names", ["Adam", "Spencer", "Ketan", "Harris"]],
+      ]);
+    });
+
+    test("finds the right object when using a model reference", () => {
+      const property = findProperty(
+        context,
+        "people",
+        "name",
+        "Frodo",
+        "pet",
+        undefined,
+      );
+
+      const propertyIndex = findPropertyIndex(
+        context,
+        "people",
+        "name",
+        "Frodo",
+      );
+
+      expect(property).toBe("cat");
+      expect(propertyIndex).toBe(1);
+    });
+
+    test("finds the right object when using direct arrays", () => {
+      const arr = [
+        {
+          name: "Adam",
+          pet: "dog",
+        },
+        {
+          name: "Frodo",
+          pet: "cat",
+        },
+      ];
+
+      const property = findProperty(
+        context,
+        arr,
+        "name",
+        "Frodo",
+        "pet",
+        undefined,
+      );
+
+      const propertyIndex = findPropertyIndex(context, arr, "name", "Frodo");
+
+      expect(property).toBe("cat");
+      expect(propertyIndex).toBe(1);
+    });
+
+    test("index not found", () => {
+      const propertyIndex = findPropertyIndex(
+        context,
+        "people",
+        "name",
+        "Spencer",
+      );
+
+      expect(propertyIndex).toBe(-1);
+    });
+
+    test("undefined binding", () => {
+      const propertyIndex = findPropertyIndex(
+        context,
+        undefined as any,
+        "name",
+        "Spencer",
+      );
+
+      expect(propertyIndex).toBe(-1);
+    });
+
+    test("non-existant model ref", () => {
+      expect(findPropertyIndex(context, "not-there", "name", "Adam")).toBe(-1);
+      expect(
+        findProperty(
+          context,
+          "not-there",
+          "name",
+          "Adam",
+          undefined,
+          "defaultVal",
+        ),
+      ).toBe("defaultVal");
+    });
+
+    test("fallback value", () => {
+      const property = findProperty(
+        context,
+        "people",
+        "name",
+        "Spencer",
+        "pet",
+        "rabbit",
+      );
+
+      expect(property).toBe("rabbit");
+    });
+
+    test("works for value arrays", () => {
+      expect(findPropertyIndex(context, "names", undefined, "Adam")).toBe(0);
+      expect(
+        findProperty(context, "names", undefined, "Adam", undefined, undefined),
+      ).toBe("Adam");
+    });
+  });
+  describe("containsAny", () => {
+    beforeEach(() => {
+      model.set([
+        [
+          "people",
+          [
+            {
+              name: "Adam",
+              pet: "dog",
+            },
+            {
+              name: "Frodo",
+              pet: "cat",
+            },
+          ],
+        ],
+        ["names", ["Adam", "Spencer", "Ketan", "Harris"]],
+      ]);
+    });
+
+    test("find a keyword from a string", () => {
+      const str = "The quick brown fox jumps over the lazy dog";
+      expect(containsAny(context, str, "fox")).toBe(true);
+      expect(containsAny(context, str, "Fox")).toBe(false);
+    });
+    test("find a keyword from an array", () => {
+      const str = "The quick brown fox jumps over the lazy dog";
+      expect(containsAny(context, str, ["fox"])).toBe(true);
+      expect(containsAny(context, str, ["Fox"])).toBe(false);
+      expect(containsAny(context, str, ["Fox", "dog"])).toBe(true);
+    });
+
+    test("should return true since keyword exists (second arg is string)", () => {
+      expect(containsAny(context, "foo", "foo")).toBe(true);
+    });
+
+    test("should return true since keyword exists (second arg is array)", () => {
+      expect(containsAny(context, "foo", ["foo", "bar"])).toBe(true);
+    });
+
+    test("should return false since keyword does not exist (second arg is array)", () => {
+      expect(containsAny(context, "fuba", ["foo", "bar"])).toBe(false);
+    });
+
+    test("should return false since keyword does not exist (second arg is string)", () => {
+      expect(containsAny(context, "foo", "bar")).toBe(false);
+    });
+
+    test("should return false since first argument is bad", () => {
+      expect(containsAny(context, null, "bar")).toBe(false);
+    });
+
+    test("should return false since second argument is bad", () => {
+      expect(containsAny(context, "foo", null)).toBe(false);
+    });
+
+    test("should return true since second argument as blank is acceptable", () => {
+      expect(containsAny(context, "foo", "")).toBe(true);
+    });
+
+    test("should return true since both arguments as blank is acceptable", () => {
+      expect(containsAny(context, "", "")).toBe(true);
+    });
+
+    test("should return false since first argument is blank and second is not", () => {
+      expect(containsAny(context, "", "bar")).toBe(false);
+    });
+
+    test("should return false since first agument is blank and second argument is an empty array", () => {
+      expect(containsAny(context, "", [])).toBe(false);
+    });
+
+    test("should return false since second argument is an empty array", () => {
+      expect(containsAny(context, "foo", [])).toBe(false);
+    });
+  });
+});

package/src/expressions/__tests__/toNum.test.ts

@@ -0,0 +1,56 @@
+import { describe, test, expect } from "vitest";
+import { toNum } from "../toNum";
+
+describe("toNum", () => {
+  test("returns the argument when provided a number", () => {
+    expect(toNum(40)).toBe(40);
+    expect(toNum(1.0)).toBe(1.0);
+  });
+
+  test("ignores all space", () => {
+    expect(toNum(" \r\n\t50\t\n\r ")).toBe(50);
+  });
+
+  test("ignores all commas", () => {
+    expect(toNum("400,000,000.00")).toBe(400000000.0);
+  });
+
+  test("ignores a single currency symbols", () => {
+    expect(toNum("¥500")).toBe(500);
+    expect(toNum("£-1")).toBe(-1);
+    expect(toNum("$33.33")).toBe(33.33);
+    expect(toNum("€20,000")).toBe(20000);
+  });
+
+  test("returns undef when the parameter has multiple currency symbols", () => {
+    expect(toNum("¥50¥0")).toBe(undefined);
+    expect(toNum("£-1£")).toBe(undefined);
+    expect(toNum("$33.33$")).toBe(undefined);
+    expect(toNum("€€20,000")).toBe(undefined);
+  });
+
+  test("returns undef if the parameter cannot be converted to number", () => {
+    expect(toNum("hello")).toBe(undefined);
+    expect(toNum({})).toBe(undefined);
+    expect(toNum(undefined)).toBe(undefined);
+  });
+
+  test("returns 0 if the provided parameter is falsy and the 2nd parameter flag is true", () => {
+    expect(toNum("", true)).toBe(0);
+    expect(toNum(null, true)).toBe(0);
+  });
+
+  test("returns undef if the provided string parameter is empty and the 2nd parameter is false", () => {
+    expect(toNum("", false)).toBe(undefined);
+  });
+
+  test("returns undef when only part of the input contains a number", () => {
+    expect(toNum("123abc")).toBe(undefined);
+  });
+
+  test("does not parse hex, octal, or binary strings", () => {
+    expect(toNum("0x123")).toBe(undefined);
+    expect(toNum("0o123")).toBe(undefined);
+    expect(toNum("0b123")).toBe(undefined);
+  });
+});

package/src/expressions/index.ts

@@ -1,12 +1,15 @@
-import type { ExpressionHandler, ExpressionContext } from '@player-ui/player';
-import { withoutContext } from '@player-ui/player';
-import type { Binding } from '@player-ui/types';
-import { toNum } from './toNum';
+import type {
+  ExpressionHandler,
+  ExpressionContext,
+  Binding,
+} from "@player-ui/player";
+import { withoutContext } from "@player-ui/player";
+import { toNum } from "./toNum";
 
 /** Returns a function that executes the given function only if the first argument is a string */
 function ifString(fn: (arg: string) => unknown) {
   return (arg: unknown) => {
-    if (typeof arg === 'string') {
+    if (typeof arg === "string") {
       return fn(arg);
     }
 
@@ -17,11 +20,11 @@ function ifString(fn: (arg: string) => unknown) {
 /** Generic Types */
 
 export const size = withoutContext((val: unknown): number => {
-  if (typeof val === 'string') {
+  if (typeof val === "string") {
     return val.length;
   }
 
-  if (typeof val === 'object' && val !== null) {
+  if (typeof val === "object" && val !== null) {
     return Object.keys(val).length;
   }
 
@@ -36,7 +39,7 @@ export const isEmpty: ExpressionHandler<[unknown], boolean> = (ctx, val) => {
     return true;
   }
 
-  if (typeof val === 'object' || typeof val === 'string') {
+  if (typeof val === "object" || typeof val === "string") {
     return size(ctx, val) === 0;
   }
 
@@ -58,7 +61,7 @@ export const concat = withoutContext((...args: Array<unknown>) => {
     });
   }
 
-  return args.reduce((merged: any, next) => merged + (next ?? ''), '');
+  return args.reduce((merged: any, next) => merged + (next ?? ""), "");
 });
 
 /** String Types */
@@ -67,31 +70,31 @@ export const trim = withoutContext(ifString((str) => str.trim()));
 export const upperCase = withoutContext(ifString((str) => str.toUpperCase()));
 export const lowerCase = withoutContext(ifString((str) => str.toLowerCase()));
 export const replace = withoutContext(
-  (str: unknown, pattern: unknown, replacement: unknown = '') => {
+  (str: unknown, pattern: unknown, replacement: unknown = "") => {
     if (
-      typeof str === 'string' &&
-      typeof pattern === 'string' &&
-      typeof replacement === 'string'
+      typeof str === "string" &&
+      typeof pattern === "string" &&
+      typeof replacement === "string"
     ) {
-      const replacementRegex = new RegExp(pattern, 'g');
+      const replacementRegex = new RegExp(pattern, "g");
 
       return str.replace(replacementRegex, replacement);
     }
 
     return str;
-  }
+  },
 );
 export const titleCase = withoutContext(
   ifString((str) =>
     str
-      .split(' ')
+      .split(" ")
       .map((word) => word[0].toUpperCase() + word.slice(1))
-      .join(' ')
-  )
+      .join(" "),
+  ),
 );
 
 export const sentenceCase = withoutContext(
-  ifString((str) => str.replace(/\b[a-zA-Z]/, (word) => word.toUpperCase()))
+  ifString((str) => str.replace(/\b[a-zA-Z]/, (word) => word.toUpperCase())),
 );
 
 /** Math Types */
@@ -99,15 +102,15 @@ export const sentenceCase = withoutContext(
 export const number = withoutContext(toNum);
 
 export const round = withoutContext<[number | string], number>((num) =>
-  Math.round(toNum(num, true) ?? 0)
+  Math.round(toNum(num, true) ?? 0),
 );
 
 export const floor = withoutContext<[number | string], number>((num) =>
-  Math.floor(toNum(num, true) ?? 0)
+  Math.floor(toNum(num, true) ?? 0),
 );
 
 export const ceil = withoutContext<[number | string], number>((num) =>
-  Math.ceil(toNum(num, true) ?? 0)
+  Math.ceil(toNum(num, true) ?? 0),
 );
 
 export const sum = withoutContext<Array<number | string>, number>((...args) => {
@@ -124,7 +127,7 @@ export const findPropertyIndex: ExpressionHandler<
   context: ExpressionContext,
   bindingOrModel: Binding | Array<Record<string, T>> | undefined,
   propToCheck: string | undefined,
-  valueToCheck: T
+  valueToCheck: T,
 ) => {
   if (bindingOrModel === undefined) {
     return -1;
@@ -140,7 +143,7 @@ export const findPropertyIndex: ExpressionHandler<
 
   return searchArray.findIndex((value) => {
     const propVal =
-      typeof value === 'object' && propToCheck !== undefined
+      typeof value === "object" && propToCheck !== undefined
         ? value[propToCheck]
         : value;
 
@@ -158,7 +161,7 @@ export const findProperty: ExpressionHandler<
   propToCheck: string | undefined,
   valueToCheck: T,
   propToReturn?: string,
-  defaultValue?: T
+  defaultValue?: T,
 ) => {
   const searchArray: Array<Record<string, T>> = Array.isArray(bindingOrModel)
     ? bindingOrModel
@@ -170,7 +173,7 @@ export const findProperty: ExpressionHandler<
 
   const foundValue = searchArray.find((value) => {
     const propVal =
-      typeof value === 'object' && propToCheck !== undefined
+      typeof value === "object" && propToCheck !== undefined
         ? value[propToCheck]
         : value;
 
@@ -181,7 +184,7 @@ export const findProperty: ExpressionHandler<
     return defaultValue;
   }
 
-  if (typeof foundValue === 'object' && propToReturn) {
+  if (typeof foundValue === "object" && propToReturn) {
     return foundValue[propToReturn] ?? defaultValue;
   }
 
@@ -197,8 +200,8 @@ export const findProperty: ExpressionHandler<
 export const containsAny = withoutContext<[string, string[] | string], boolean>(
   (str, keywords) => {
     if (
-      !(typeof str === 'string') ||
-      !(typeof keywords === 'string' || Array.isArray(keywords))
+      !(typeof str === "string") ||
+      !(typeof keywords === "string" || Array.isArray(keywords))
     ) {
       return false;
     }
@@ -208,5 +211,5 @@ export const containsAny = withoutContext<[string, string[] | string], boolean>(
     }
 
     return str.indexOf(keywords) > -1;
-  }
+  },
 );