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

package/src/expressions/toNum.ts

@@ -2,17 +2,17 @@
  * Convert a string that might contain formatting (such as commas and a currency symbol) to a number
  */
 export function toNum(val: unknown, coerceTo0?: boolean): number | undefined {
-  if (typeof val === 'number') {
+  if (typeof val === "number") {
     return val;
   }
 
-  if (typeof val === 'string' && val.length > 0) {
+  if (typeof val === "string" && val.length > 0) {
     // Trim whitespace
     let newVal = val.trim();
     // Remove all commas
-    newVal = newVal.replace(/,/g, '');
+    newVal = newVal.replace(/,/g, "");
     // Remove up to 1 commonly-used currency symbol
-    newVal = newVal.replace(/[¥£$€]/, '');
+    newVal = newVal.replace(/[¥£$€]/, "");
     const nVal = Number(newVal);
 
     // ignore hex, binary, octal, and values that don't parse

package/src/index.test.ts

@@ -0,0 +1,31 @@
+import { expect, test } from "vitest";
+import type { InProgressState } from "@player-ui/player";
+import { Player } from "@player-ui/player";
+import { makeFlow } from "@player-ui/make-flow";
+import { CommonExpressionsPlugin } from ".";
+
+test("works in real life", () => {
+  const flow = makeFlow({
+    id: "view-1",
+    type: "info",
+    fields: {
+      asset: {
+        id: "input-1",
+        type: "text",
+        value: "@[titleCase('hello world')]@",
+      },
+    },
+  });
+
+  const player = new Player({
+    plugins: [new CommonExpressionsPlugin()],
+  });
+
+  player.start(flow);
+
+  const state = player.getState() as InProgressState;
+
+  expect(
+    state.controllers.view.currentView?.lastUpdate?.fields.asset.value,
+  ).toBe("Hello World");
+});

package/src/index.ts

@@ -1,6 +1,6 @@
-import type { ExtendedPlayerPlugin, Player } from '@player-ui/player';
-import { ExpressionPlugin } from '@player-ui/expression-plugin';
-import * as Expressions from './expressions';
+import type { ExtendedPlayerPlugin, Player } from "@player-ui/player";
+import { ExpressionPlugin } from "@player-ui/expression-plugin";
+import * as Expressions from "./expressions";
 import type {
   size,
   length,
@@ -21,7 +21,7 @@ import type {
   findPropertyIndex,
   findProperty,
   containsAny,
-} from './expressions';
+} from "./expressions";
 /**
  * Exposes a lot of expressions to Player.
  */
@@ -49,15 +49,15 @@ export class CommonExpressionsPlugin
         typeof sum,
         typeof findPropertyIndex,
         typeof findProperty,
-        typeof containsAny
+        typeof containsAny,
       ]
     >
 {
-  name = 'CommonExpressions';
+  name = "CommonExpressions";
 
   apply(player: Player) {
     player.registerPlugin(
-      new ExpressionPlugin(new Map(Object.entries(Expressions)))
+      new ExpressionPlugin(new Map(Object.entries(Expressions))),
     );
   }
 }

package/types/expressions/index.d.ts

@@ -0,0 +1,39 @@
+import type { ExpressionHandler, Binding } from "@player-ui/player";
+/** Generic Types */
+export declare const size: ExpressionHandler<[val: unknown], number>;
+export declare const length: ExpressionHandler<[val: unknown], number>;
+/** Checks to see if the given value is empty */
+export declare const isEmpty: ExpressionHandler<[unknown], boolean>;
+/** Checks to see if the given value is not empty */
+export declare const isNotEmpty: ExpressionHandler<[unknown], boolean>;
+export declare const concat: ExpressionHandler<unknown[], unknown>;
+/** String Types */
+export declare const trim: ExpressionHandler<[arg: unknown], unknown>;
+export declare const upperCase: ExpressionHandler<[arg: unknown], unknown>;
+export declare const lowerCase: ExpressionHandler<[arg: unknown], unknown>;
+export declare const replace: ExpressionHandler<[str: unknown, pattern: unknown, replacement?: unknown], unknown>;
+export declare const titleCase: ExpressionHandler<[arg: unknown], unknown>;
+export declare const sentenceCase: ExpressionHandler<[arg: unknown], unknown>;
+/** Math Types */
+export declare const number: ExpressionHandler<[val: unknown, coerceTo0?: boolean | undefined], number | undefined>;
+export declare const round: ExpressionHandler<[string | number], number>;
+export declare const floor: ExpressionHandler<[string | number], number>;
+export declare const ceil: ExpressionHandler<[string | number], number>;
+export declare const sum: ExpressionHandler<(string | number)[], number>;
+/** Array Operations */
+/** Finds the property in an array of objects */
+export declare const findPropertyIndex: ExpressionHandler<[
+    Array<any> | Binding | undefined,
+    string | undefined,
+    any
+], number>;
+/** Searches an array for an object matching the criteria. Returns the target prop from that object */
+export declare const findProperty: ExpressionHandler<[
+    Array<any> | Binding,
+    string | undefined,
+    any,
+    string | undefined,
+    any
+], any>;
+export declare const containsAny: ExpressionHandler<[string, string | string[]], boolean>;
+//# sourceMappingURL=index.d.ts.map

package/types/expressions/toNum.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert a string that might contain formatting (such as commas and a currency symbol) to a number
+ */
+export declare function toNum(val: unknown, coerceTo0?: boolean): number | undefined;
+//# sourceMappingURL=toNum.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,32 @@
+import type { ExtendedPlayerPlugin, Player } from "@player-ui/player";
+import type { size, length, isEmpty, isNotEmpty, concat, trim, upperCase, lowerCase, replace, titleCase, sentenceCase, number, round, floor, ceil, sum, findPropertyIndex, findProperty, containsAny } from "./expressions";
+/**
+ * Exposes a lot of expressions to Player.
+ */
+export declare class CommonExpressionsPlugin implements ExtendedPlayerPlugin<[
+], [
+], [
+    typeof size,
+    typeof length,
+    typeof isEmpty,
+    typeof isNotEmpty,
+    typeof concat,
+    typeof trim,
+    typeof upperCase,
+    typeof lowerCase,
+    typeof replace,
+    typeof titleCase,
+    typeof sentenceCase,
+    typeof number,
+    typeof round,
+    typeof floor,
+    typeof ceil,
+    typeof sum,
+    typeof findPropertyIndex,
+    typeof findProperty,
+    typeof containsAny
+]> {
+    name: string;
+    apply(player: Player): void;
+}
+//# sourceMappingURL=index.d.ts.map