@player-ui/common-expressions-plugin 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,148 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var expressionPlugin = require('@player-ui/expression-plugin');
+var expressions = require('@player-ui/expressions');
+var utils = require('@player-ui/utils');
+
+function ifString(fn) {
+  return (arg) => {
+    if (typeof arg === "string") {
+      return fn(arg);
+    }
+    return arg;
+  };
+}
+const size = expressions.withoutContext((val) => {
+  if (typeof val === "string") {
+    return val.length;
+  }
+  if (typeof val === "object" && val !== null) {
+    return Object.keys(val).length;
+  }
+  return 0;
+});
+const length = size;
+const isEmpty = (ctx, val) => {
+  if (val === void 0 || val === null) {
+    return true;
+  }
+  if (typeof val === "object" || typeof val === "string") {
+    return size(ctx, val) === 0;
+  }
+  return false;
+};
+const isNotEmpty = (ctx, val) => {
+  return !isEmpty(ctx, val);
+};
+const concat = expressions.withoutContext((...args) => {
+  if (args.every((v) => Array.isArray(v))) {
+    const arrayArgs = args;
+    return arrayArgs.reduce((merged, next) => [...merged, ...next]);
+  }
+  return args.reduce((merged, next) => merged + (next != null ? next : ""), "");
+});
+const trim = expressions.withoutContext(ifString((str) => str.trim()));
+const upperCase = expressions.withoutContext(ifString((str) => str.toUpperCase()));
+const lowerCase = expressions.withoutContext(ifString((str) => str.toLowerCase()));
+const replace = expressions.withoutContext((str, pattern, replacement = "") => {
+  if (typeof str === "string" && typeof pattern === "string" && typeof replacement === "string") {
+    const replacementRegex = new RegExp(pattern, "g");
+    return str.replace(replacementRegex, replacement);
+  }
+  return str;
+});
+const titleCase = expressions.withoutContext(ifString((str) => str.split(" ").map((word) => word[0].toUpperCase() + word.slice(1)).join(" ")));
+const sentenceCase = expressions.withoutContext(ifString((str) => str.replace(/\b[a-zA-Z]/, (word) => word.toUpperCase())));
+const number = expressions.withoutContext(utils.toNum);
+const round = expressions.withoutContext((num) => {
+  var _a;
+  return Math.round((_a = utils.toNum(num, true)) != null ? _a : 0);
+});
+const floor = expressions.withoutContext((num) => {
+  var _a;
+  return Math.floor((_a = utils.toNum(num, true)) != null ? _a : 0);
+});
+const ceil = expressions.withoutContext((num) => {
+  var _a;
+  return Math.ceil((_a = utils.toNum(num, true)) != null ? _a : 0);
+});
+const sum = expressions.withoutContext((...args) => {
+  return args.reduce((s, next) => {
+    var _a;
+    return s + ((_a = utils.toNum(next)) != null ? _a : 0);
+  }, 0);
+});
+const findPropertyIndex = (context, bindingOrModel, propToCheck, valueToCheck) => {
+  const searchArray = Array.isArray(bindingOrModel) ? bindingOrModel : context.model.get(bindingOrModel);
+  if (!Array.isArray(searchArray)) {
+    return -1;
+  }
+  return searchArray.findIndex((value) => {
+    const propVal = typeof value === "object" && propToCheck !== void 0 ? value[propToCheck] : value;
+    return valueToCheck === propVal;
+  });
+};
+const findProperty = (context, bindingOrModel, propToCheck, valueToCheck, propToReturn, defaultValue) => {
+  var _a;
+  const searchArray = Array.isArray(bindingOrModel) ? bindingOrModel : context.model.get(bindingOrModel);
+  if (!Array.isArray(searchArray)) {
+    return defaultValue;
+  }
+  const foundValue = searchArray.find((value) => {
+    const propVal = typeof value === "object" && propToCheck !== void 0 ? value[propToCheck] : value;
+    return valueToCheck === propVal;
+  });
+  if (foundValue === void 0) {
+    return defaultValue;
+  }
+  if (typeof foundValue === "object" && propToReturn) {
+    return (_a = foundValue[propToReturn]) != null ? _a : defaultValue;
+  }
+  return foundValue;
+};
+const containsAny = expressions.withoutContext((str, keywords) => {
+  if (!(typeof str === "string") || !(typeof keywords === "string" || Array.isArray(keywords))) {
+    return false;
+  }
+  if (Array.isArray(keywords)) {
+    return keywords.some((keyword) => str.indexOf(keyword) > -1);
+  }
+  return str.indexOf(keywords) > -1;
+});
+
+var Expressions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  size: size,
+  length: length,
+  isEmpty: isEmpty,
+  isNotEmpty: isNotEmpty,
+  concat: concat,
+  trim: trim,
+  upperCase: upperCase,
+  lowerCase: lowerCase,
+  replace: replace,
+  titleCase: titleCase,
+  sentenceCase: sentenceCase,
+  number: number,
+  round: round,
+  floor: floor,
+  ceil: ceil,
+  sum: sum,
+  findPropertyIndex: findPropertyIndex,
+  findProperty: findProperty,
+  containsAny: containsAny
+});
+
+class CommonExpressionsPlugin {
+  constructor() {
+    this.name = "CommonExpressions";
+  }
+  apply(player) {
+    player.registerPlugin(new expressionPlugin.ExpressionPlugin(new Map(Object.entries(Expressions))));
+  }
+}
+
+exports.CommonExpressionsPlugin = CommonExpressionsPlugin;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { PlayerPlugin, Player } from '@player-ui/player';
+
+/**
+ * Exposes a lot of expressions to Player.
+ */
+declare class CommonExpressionsPlugin implements PlayerPlugin {
+    name: string;
+    apply(player: Player): void;
+}
+
+export { CommonExpressionsPlugin };

package/dist/index.esm.js

@@ -0,0 +1,144 @@
+import { ExpressionPlugin } from '@player-ui/expression-plugin';
+import { withoutContext } from '@player-ui/expressions';
+import { toNum } from '@player-ui/utils';
+
+function ifString(fn) {
+  return (arg) => {
+    if (typeof arg === "string") {
+      return fn(arg);
+    }
+    return arg;
+  };
+}
+const size = withoutContext((val) => {
+  if (typeof val === "string") {
+    return val.length;
+  }
+  if (typeof val === "object" && val !== null) {
+    return Object.keys(val).length;
+  }
+  return 0;
+});
+const length = size;
+const isEmpty = (ctx, val) => {
+  if (val === void 0 || val === null) {
+    return true;
+  }
+  if (typeof val === "object" || typeof val === "string") {
+    return size(ctx, val) === 0;
+  }
+  return false;
+};
+const isNotEmpty = (ctx, val) => {
+  return !isEmpty(ctx, val);
+};
+const concat = withoutContext((...args) => {
+  if (args.every((v) => Array.isArray(v))) {
+    const arrayArgs = args;
+    return arrayArgs.reduce((merged, next) => [...merged, ...next]);
+  }
+  return args.reduce((merged, next) => merged + (next != null ? next : ""), "");
+});
+const trim = withoutContext(ifString((str) => str.trim()));
+const upperCase = withoutContext(ifString((str) => str.toUpperCase()));
+const lowerCase = withoutContext(ifString((str) => str.toLowerCase()));
+const replace = withoutContext((str, pattern, replacement = "") => {
+  if (typeof str === "string" && typeof pattern === "string" && typeof replacement === "string") {
+    const replacementRegex = new RegExp(pattern, "g");
+    return str.replace(replacementRegex, replacement);
+  }
+  return str;
+});
+const titleCase = withoutContext(ifString((str) => str.split(" ").map((word) => word[0].toUpperCase() + word.slice(1)).join(" ")));
+const sentenceCase = withoutContext(ifString((str) => str.replace(/\b[a-zA-Z]/, (word) => word.toUpperCase())));
+const number = withoutContext(toNum);
+const round = withoutContext((num) => {
+  var _a;
+  return Math.round((_a = toNum(num, true)) != null ? _a : 0);
+});
+const floor = withoutContext((num) => {
+  var _a;
+  return Math.floor((_a = toNum(num, true)) != null ? _a : 0);
+});
+const ceil = withoutContext((num) => {
+  var _a;
+  return Math.ceil((_a = toNum(num, true)) != null ? _a : 0);
+});
+const sum = withoutContext((...args) => {
+  return args.reduce((s, next) => {
+    var _a;
+    return s + ((_a = toNum(next)) != null ? _a : 0);
+  }, 0);
+});
+const findPropertyIndex = (context, bindingOrModel, propToCheck, valueToCheck) => {
+  const searchArray = Array.isArray(bindingOrModel) ? bindingOrModel : context.model.get(bindingOrModel);
+  if (!Array.isArray(searchArray)) {
+    return -1;
+  }
+  return searchArray.findIndex((value) => {
+    const propVal = typeof value === "object" && propToCheck !== void 0 ? value[propToCheck] : value;
+    return valueToCheck === propVal;
+  });
+};
+const findProperty = (context, bindingOrModel, propToCheck, valueToCheck, propToReturn, defaultValue) => {
+  var _a;
+  const searchArray = Array.isArray(bindingOrModel) ? bindingOrModel : context.model.get(bindingOrModel);
+  if (!Array.isArray(searchArray)) {
+    return defaultValue;
+  }
+  const foundValue = searchArray.find((value) => {
+    const propVal = typeof value === "object" && propToCheck !== void 0 ? value[propToCheck] : value;
+    return valueToCheck === propVal;
+  });
+  if (foundValue === void 0) {
+    return defaultValue;
+  }
+  if (typeof foundValue === "object" && propToReturn) {
+    return (_a = foundValue[propToReturn]) != null ? _a : defaultValue;
+  }
+  return foundValue;
+};
+const containsAny = withoutContext((str, keywords) => {
+  if (!(typeof str === "string") || !(typeof keywords === "string" || Array.isArray(keywords))) {
+    return false;
+  }
+  if (Array.isArray(keywords)) {
+    return keywords.some((keyword) => str.indexOf(keyword) > -1);
+  }
+  return str.indexOf(keywords) > -1;
+});
+
+var Expressions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  size: size,
+  length: length,
+  isEmpty: isEmpty,
+  isNotEmpty: isNotEmpty,
+  concat: concat,
+  trim: trim,
+  upperCase: upperCase,
+  lowerCase: lowerCase,
+  replace: replace,
+  titleCase: titleCase,
+  sentenceCase: sentenceCase,
+  number: number,
+  round: round,
+  floor: floor,
+  ceil: ceil,
+  sum: sum,
+  findPropertyIndex: findPropertyIndex,
+  findProperty: findProperty,
+  containsAny: containsAny
+});
+
+class CommonExpressionsPlugin {
+  constructor() {
+    this.name = "CommonExpressions";
+  }
+  apply(player) {
+    player.registerPlugin(new ExpressionPlugin(new Map(Object.entries(Expressions))));
+  }
+}
+
+export { CommonExpressionsPlugin };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@player-ui/common-expressions-plugin",
+  "version": "0.0.1-next.1",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {
+    "@player-ui/binding-grammar": "0.0.1-next.1"
+  },
+  "dependencies": {
+    "@player-ui/utils": "0.0.1-next.1",
+    "@player-ui/binding-grammar": "0.0.1-next.1",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts"
+}

package/src/expressions/index.ts

@@ -0,0 +1,208 @@
+import type {
+  ExpressionHandler,
+  ExpressionContext,
+} from '@player-ui/expressions';
+import { withoutContext } from '@player-ui/expressions';
+import { toNum } from '@player-ui/utils';
+import type { Binding } from '@player-ui/types';
+
+/** 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') {
+      return fn(arg);
+    }
+
+    return arg;
+  };
+}
+
+/** Generic Types */
+
+export const size = withoutContext((val: unknown): number => {
+  if (typeof val === 'string') {
+    return val.length;
+  }
+
+  if (typeof val === 'object' && val !== null) {
+    return Object.keys(val).length;
+  }
+
+  return 0;
+});
+
+export const length = size;
+
+/** Checks to see if the given value is empty */
+export const isEmpty: ExpressionHandler<[unknown], boolean> = (ctx, val) => {
+  if (val === undefined || val === null) {
+    return true;
+  }
+
+  if (typeof val === 'object' || typeof val === 'string') {
+    return size(ctx, val) === 0;
+  }
+
+  return false;
+};
+
+/** Checks to see if the given value is not empty */
+export const isNotEmpty: ExpressionHandler<[unknown], boolean> = (ctx, val) => {
+  return !isEmpty(ctx, val);
+};
+
+export const concat = withoutContext((...args: Array<unknown>) => {
+  if (args.every((v) => Array.isArray(v))) {
+    const arrayArgs = args as Array<Array<unknown>>;
+
+    return arrayArgs.reduce((merged, next) => [...merged, ...next]);
+  }
+
+  return args.reduce((merged: any, next) => merged + (next ?? ''), '');
+});
+
+/** String Types */
+
+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 = '') => {
+    if (
+      typeof str === 'string' &&
+      typeof pattern === 'string' &&
+      typeof replacement === 'string'
+    ) {
+      const replacementRegex = new RegExp(pattern, 'g');
+
+      return str.replace(replacementRegex, replacement);
+    }
+
+    return str;
+  }
+);
+export const titleCase = withoutContext(
+  ifString((str) =>
+    str
+      .split(' ')
+      .map((word) => word[0].toUpperCase() + word.slice(1))
+      .join(' ')
+  )
+);
+
+export const sentenceCase = withoutContext(
+  ifString((str) => str.replace(/\b[a-zA-Z]/, (word) => word.toUpperCase()))
+);
+
+/** Math Types */
+
+export const number = withoutContext(toNum);
+
+export const round = withoutContext<[number | string], number>((num) =>
+  Math.round(toNum(num, true) ?? 0)
+);
+
+export const floor = withoutContext<[number | string], number>((num) =>
+  Math.floor(toNum(num, true) ?? 0)
+);
+
+export const ceil = withoutContext<[number | string], number>((num) =>
+  Math.ceil(toNum(num, true) ?? 0)
+);
+
+export const sum = withoutContext<Array<number | string>, number>((...args) => {
+  return args.reduce<number>((s, next) => s + (toNum(next) ?? 0), 0);
+});
+
+/** Array Operations */
+
+/** Finds the property in an array of objects */
+export const findPropertyIndex: ExpressionHandler<
+  [Array<any> | Binding, string | undefined, any],
+  number
+> = <T = unknown>(
+  context: ExpressionContext,
+  bindingOrModel: Binding | Array<Record<string, T>>,
+  propToCheck: string | undefined,
+  valueToCheck: T
+) => {
+  const searchArray: Array<Record<string, T>> = Array.isArray(bindingOrModel)
+    ? bindingOrModel
+    : context.model.get(bindingOrModel);
+
+  if (!Array.isArray(searchArray)) {
+    return -1;
+  }
+
+  return searchArray.findIndex((value) => {
+    const propVal =
+      typeof value === 'object' && propToCheck !== undefined
+        ? value[propToCheck]
+        : value;
+
+    return valueToCheck === propVal;
+  });
+};
+
+/** Searches an array for an object matching the criteria. Returns the target prop from that object */
+export const findProperty: ExpressionHandler<
+  [Array<any> | Binding, string | undefined, any, string | undefined, any],
+  any
+> = <T = unknown>(
+  context: ExpressionContext,
+  bindingOrModel: Binding | Array<Record<string, T>>,
+  propToCheck: string | undefined,
+  valueToCheck: T,
+  propToReturn?: string,
+  defaultValue?: T
+) => {
+  const searchArray: Array<Record<string, T>> = Array.isArray(bindingOrModel)
+    ? bindingOrModel
+    : context.model.get(bindingOrModel);
+
+  if (!Array.isArray(searchArray)) {
+    return defaultValue;
+  }
+
+  const foundValue = searchArray.find((value) => {
+    const propVal =
+      typeof value === 'object' && propToCheck !== undefined
+        ? value[propToCheck]
+        : value;
+
+    return valueToCheck === propVal;
+  });
+
+  if (foundValue === undefined) {
+    return defaultValue;
+  }
+
+  if (typeof foundValue === 'object' && propToReturn) {
+    return foundValue[propToReturn] ?? defaultValue;
+  }
+
+  return foundValue;
+};
+
+/*
+ * Checks if a given string contains any keywords present in the given array
+ * @param str: The string to search in
+ * @param searchStrs: A keyword(s) to search for
+ # @returns boolean: Return true if any of the keywords exist in the given string
+ */
+export const containsAny = withoutContext<[string, string[] | string], boolean>(
+  (str, keywords) => {
+    if (
+      !(typeof str === 'string') ||
+      !(typeof keywords === 'string' || Array.isArray(keywords))
+    ) {
+      return false;
+    }
+
+    if (Array.isArray(keywords)) {
+      return keywords.some((keyword) => str.indexOf(keyword) > -1);
+    }
+
+    return str.indexOf(keywords) > -1;
+  }
+);

package/src/index.ts

@@ -0,0 +1,16 @@
+import type { Player, PlayerPlugin } from '@player-ui/player';
+import { ExpressionPlugin } from '@player-ui/expression-plugin';
+import * as Expressions from './expressions';
+
+/**
+ * Exposes a lot of expressions to Player.
+ */
+export class CommonExpressionsPlugin implements PlayerPlugin {
+  name = 'CommonExpressions';
+
+  apply(player: Player) {
+    player.registerPlugin(
+      new ExpressionPlugin(new Map(Object.entries(Expressions)))
+    );
+  }
+}