@player-ui/asset-transform-plugin 0.7.4-next.4 → 0.7.5--canary.434.14868

package/src/__tests__/propertiesToSkip.test.ts

@@ -0,0 +1,445 @@
+import { test, expect, describe } from "vitest";
+import type { Node } from "@player-ui/player";
+import { Parser } from "@player-ui/player";
+import { composeBefore, propertiesToSkipTransform } from "..";
+
+const parser = new Parser();
+
+const actionAsset = {
+  id: "action",
+  type: "action",
+  exp: "{{count}} = {{count}} + 1",
+  label: {
+    asset: {
+      id: "action-label",
+      type: "text",
+      value: "Count: {{count}}",
+    },
+  },
+};
+
+const actionAssetNode: Node.Asset = parser.parseObject(
+  actionAsset,
+) as Node.Asset;
+
+const actionAsset2 = {
+  id: "action",
+  type: "action",
+  exp: "{{count}} = {{count}} + 1",
+  label: {
+    asset: {
+      id: "action-label",
+      type: "text",
+      value: "Count: {{count}}",
+    },
+  },
+  plugins: {
+    stringResolver: {
+      propertiesToSkip: ["exp"],
+    },
+  },
+};
+
+const actionAsset2Node: Node.Asset = parser.parseObject(
+  actionAsset2,
+) as Node.Asset;
+
+describe("propertiesToSkip", () => {
+  test("adds exp to the plugin stringResolver.propertiesToSkip", () => {
+    const before = composeBefore(propertiesToSkipTransform(["exp"]));
+
+    expect(before).toStrictEqual(
+      expect.objectContaining({
+        beforeResolve: expect.any(Function),
+      }),
+    );
+
+    expect(before.beforeResolve?.(actionAssetNode, {} as any, {} as any))
+      .toMatchInlineSnapshot(`
+        {
+          "children": [
+            {
+              "path": [
+                "label",
+                "asset",
+              ],
+              "value": {
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "asset",
+                "value": {
+                  "id": "action-label",
+                  "type": "text",
+                  "value": "Count: {{count}}",
+                },
+              },
+            },
+          ],
+          "plugins": {
+            "stringResolver": {
+              "propertiesToSkip": [
+                "exp",
+              ],
+            },
+          },
+          "type": "value",
+          "value": {
+            "exp": "{{count}} = {{count}} + 1",
+            "id": "action",
+            "type": "action",
+          },
+        }
+      `);
+  });
+
+  test("Does not duplicate if propertiesToSkip already contains the value", () => {
+    const before = composeBefore(propertiesToSkipTransform(["exp"]));
+
+    expect(before).toStrictEqual(
+      expect.objectContaining({
+        beforeResolve: expect.any(Function),
+      }),
+    );
+
+    expect(before.beforeResolve?.(actionAsset2Node, {} as any, {} as any))
+      .toMatchInlineSnapshot(`
+        {
+          "children": [
+            {
+              "path": [
+                "label",
+                "asset",
+              ],
+              "value": {
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "asset",
+                "value": {
+                  "id": "action-label",
+                  "type": "text",
+                  "value": "Count: {{count}}",
+                },
+              },
+            },
+            {
+              "path": [
+                "plugins",
+                "stringResolver",
+                "propertiesToSkip",
+              ],
+              "value": {
+                "override": true,
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "multi-node",
+                "values": [
+                  {
+                    "parent": [Circular],
+                    "type": "value",
+                    "value": "exp",
+                  },
+                ],
+              },
+            },
+          ],
+          "plugins": {
+            "stringResolver": {
+              "propertiesToSkip": [
+                "exp",
+              ],
+            },
+          },
+          "type": "value",
+          "value": {
+            "exp": "{{count}} = {{count}} + 1",
+            "id": "action",
+            "type": "action",
+          },
+        }
+      `);
+  });
+
+  test("Does not add an empty array", () => {
+    const before = composeBefore(propertiesToSkipTransform([""]));
+
+    expect(before).toStrictEqual(
+      expect.objectContaining({
+        beforeResolve: expect.any(Function),
+      }),
+    );
+
+    expect(before.beforeResolve?.(actionAssetNode, {} as any, {} as any))
+      .toMatchInlineSnapshot(`
+        {
+          "children": [
+            {
+              "path": [
+                "label",
+                "asset",
+              ],
+              "value": {
+                "parent": [Circular],
+                "type": "asset",
+                "value": {
+                  "id": "action-label",
+                  "type": "text",
+                  "value": "Count: {{count}}",
+                },
+              },
+            },
+          ],
+          "type": "value",
+          "value": {
+            "exp": "{{count}} = {{count}} + 1",
+            "id": "action",
+            "type": "action",
+          },
+        }
+      `);
+  });
+
+  test("Returns original Asset if the parameter passed in an empty array", () => {
+    const before = composeBefore(propertiesToSkipTransform([""]));
+
+    expect(before).toStrictEqual(
+      expect.objectContaining({
+        beforeResolve: expect.any(Function),
+      }),
+    );
+
+    expect(before.beforeResolve?.(actionAsset2Node, {} as any, {} as any))
+      .toMatchInlineSnapshot(`
+        {
+          "children": [
+            {
+              "path": [
+                "label",
+                "asset",
+              ],
+              "value": {
+                "parent": [Circular],
+                "type": "asset",
+                "value": {
+                  "id": "action-label",
+                  "type": "text",
+                  "value": "Count: {{count}}",
+                },
+              },
+            },
+            {
+              "path": [
+                "plugins",
+                "stringResolver",
+                "propertiesToSkip",
+              ],
+              "value": {
+                "override": true,
+                "parent": [Circular],
+                "type": "multi-node",
+                "values": [
+                  {
+                    "parent": [Circular],
+                    "type": "value",
+                    "value": "exp",
+                  },
+                ],
+              },
+            },
+          ],
+          "type": "value",
+          "value": {
+            "exp": "{{count}} = {{count}} + 1",
+            "id": "action",
+            "type": "action",
+          },
+        }
+      `);
+  });
+
+  test("Adds multiple values to propertiesToSkip, but skips empty strings", () => {
+    const before = composeBefore(
+      propertiesToSkipTransform(["exp", "", "", "label"]),
+    );
+
+    expect(before).toStrictEqual(
+      expect.objectContaining({
+        beforeResolve: expect.any(Function),
+      }),
+    );
+
+    expect(before.beforeResolve?.(actionAsset2Node, {} as any, {} as any))
+      .toMatchInlineSnapshot(`
+        {
+          "children": [
+            {
+              "path": [
+                "label",
+                "asset",
+              ],
+              "value": {
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "asset",
+                "value": {
+                  "id": "action-label",
+                  "type": "text",
+                  "value": "Count: {{count}}",
+                },
+              },
+            },
+            {
+              "path": [
+                "plugins",
+                "stringResolver",
+                "propertiesToSkip",
+              ],
+              "value": {
+                "override": true,
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "multi-node",
+                "values": [
+                  {
+                    "parent": [Circular],
+                    "type": "value",
+                    "value": "exp",
+                  },
+                ],
+              },
+            },
+          ],
+          "plugins": {
+            "stringResolver": {
+              "propertiesToSkip": [
+                "exp",
+                "label",
+              ],
+            },
+          },
+          "type": "value",
+          "value": {
+            "exp": "{{count}} = {{count}} + 1",
+            "id": "action",
+            "type": "action",
+          },
+        }
+      `);
+  });
+
+  test("Adds values to propertiesToSkip and retains original values", () => {
+    const before = composeBefore(propertiesToSkipTransform(["label", "test"]));
+
+    expect(before).toStrictEqual(
+      expect.objectContaining({
+        beforeResolve: expect.any(Function),
+      }),
+    );
+
+    expect(before.beforeResolve?.(actionAsset2Node, {} as any, {} as any))
+      .toMatchInlineSnapshot(`
+        {
+          "children": [
+            {
+              "path": [
+                "label",
+                "asset",
+              ],
+              "value": {
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "asset",
+                "value": {
+                  "id": "action-label",
+                  "type": "text",
+                  "value": "Count: {{count}}",
+                },
+              },
+            },
+            {
+              "path": [
+                "plugins",
+                "stringResolver",
+                "propertiesToSkip",
+              ],
+              "value": {
+                "override": true,
+                "parent": {
+                  "children": [Circular],
+                  "type": "value",
+                  "value": {
+                    "exp": "{{count}} = {{count}} + 1",
+                    "id": "action",
+                    "type": "action",
+                  },
+                },
+                "type": "multi-node",
+                "values": [
+                  {
+                    "parent": [Circular],
+                    "type": "value",
+                    "value": "exp",
+                  },
+                ],
+              },
+            },
+          ],
+          "plugins": {
+            "stringResolver": {
+              "propertiesToSkip": [
+                "label",
+                "test",
+              ],
+            },
+          },
+          "type": "value",
+          "value": {
+            "exp": "{{count}} = {{count}} + 1",
+            "id": "action",
+            "type": "action",
+          },
+        }
+      `);
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,170 @@
+import { test, expect } from "vitest";
+import type {
+  TransformFunction,
+  TransformFunctions,
+  BeforeTransformFunction,
+  Node,
+} from "@player-ui/player";
+import type { Asset } from "@player-ui/types";
+import { compose, composeBefore } from "../utils";
+
+interface TextAsset extends Asset<"text"> {
+  /**
+   *
+   */
+  value: string;
+  /**
+   *
+   */
+  metaData?: {
+    /**
+     *
+     */
+    sensitive?: boolean;
+    /**
+     *
+     */
+    size?: any;
+  };
+}
+
+const textAsset: TextAsset = {
+  id: "textAsset",
+  type: "text",
+  value: "Text",
+};
+
+const textNode: Node.Asset<TextAsset> = {
+  type: "asset" as any,
+  value: textAsset,
+};
+
+/**
+ *
+ */
+const transform1: TransformFunction<TextAsset> = (asset) => asset;
+/**
+ *
+ */
+const transform2: TransformFunction<TextAsset> = (asset) => ({
+  ...asset,
+  metaData: { sensitive: true },
+});
+const transform3: TransformFunctions = {
+  resolve: (asset) => ({
+    ...asset,
+    metaData: { ...asset.metaData, size: "large" },
+  }),
+};
+const transform4: TransformFunctions = {
+  resolve: (asset) => asset,
+  beforeResolve: (node) => node,
+};
+/**
+ *
+ */
+const beforeTransform: BeforeTransformFunction<TextAsset> = (node) => node;
+/**
+ *
+ */
+const beforeTransformWithChildren: BeforeTransformFunction<TextAsset> = (
+  node,
+) => ({
+  ...node,
+  children: [],
+});
+
+test("creates a transform function object with beforeResolve and resolve functions", () => {
+  const composedTransform = compose(transform1, composeBefore(beforeTransform));
+
+  expect(composedTransform).toStrictEqual(
+    expect.objectContaining({
+      beforeResolve: expect.any(Function),
+      resolve: expect.any(Function),
+    }),
+  );
+
+  const composedWithTransformFunctionsArg = compose(transform1, transform4);
+
+  expect(composedWithTransformFunctionsArg).toStrictEqual(
+    expect.objectContaining({
+      beforeResolve: expect.any(Function),
+      resolve: expect.any(Function),
+    }),
+  );
+});
+
+test("correctly compose the functions together", () => {
+  const composedTransform = compose(transform3, transform2, transform1);
+
+  expect(composedTransform.resolve?.(textAsset, {} as any, {} as any))
+    .toMatchInlineSnapshot(`
+      {
+        "id": "textAsset",
+        "metaData": {
+          "sensitive": true,
+          "size": "large",
+        },
+        "type": "text",
+        "value": "Text",
+      }
+    `);
+
+  // Since no deep merges, it overrides `metaData`
+  const composedWithOverrideTransform = compose(
+    transform2,
+    transform3,
+    transform1,
+  );
+  expect(
+    composedWithOverrideTransform.resolve?.(textAsset, {} as any, {} as any),
+  ).toMatchInlineSnapshot(`
+    {
+      "id": "textAsset",
+      "metaData": {
+        "sensitive": true,
+      },
+      "type": "text",
+      "value": "Text",
+    }
+  `);
+});
+
+test("composeBefore correctly composes any functions together", () => {
+  const before = composeBefore(beforeTransformWithChildren, beforeTransform);
+
+  expect(before).toStrictEqual(
+    expect.objectContaining({
+      beforeResolve: expect.any(Function),
+    }),
+  );
+
+  expect(before.beforeResolve?.(textNode, {} as any, {} as any))
+    .toMatchInlineSnapshot(`
+      {
+        "children": [],
+        "type": "asset",
+        "value": {
+          "id": "textAsset",
+          "type": "text",
+          "value": "Text",
+        },
+      }
+    `);
+});
+
+test("returns correctly with only one function", () => {
+  const composedTransform = compose(transform2);
+
+  expect(composedTransform.resolve?.(textAsset, {} as any, {} as any))
+    .toMatchInlineSnapshot(`
+      {
+        "id": "textAsset",
+        "metaData": {
+          "sensitive": true,
+        },
+        "type": "text",
+        "value": "Text",
+      }
+    `);
+});

package/src/index.ts

@@ -4,12 +4,12 @@ import type {
   TransformRegistry,
   TransformFunction,
   TransformFunctions,
-} from '@player-ui/player';
-import { Registry } from '@player-ui/partial-match-registry';
-import { compose } from './utils';
+} from "@player-ui/player";
+import { Registry } from "@player-ui/partial-match-registry";
+import { compose } from "./utils";
 
-export * from './utils';
-export * from './propertiesToSkip';
+export * from "./utils";
+export * from "./propertiesToSkip";
 
 export type TransformType = TransformFunction<any> | TransformFunctions;
 export type TransformRegistryEntries = Array<[any, TransformType]>;
@@ -22,7 +22,7 @@ export type AssetTransformInit =
  * the resolve & beforeResolve functions.
  */
 function maybeCompose(maybeFn: any): TransformFunctions {
-  if (typeof maybeFn === 'object') {
+  if (typeof maybeFn === "object") {
     return maybeFn;
   }
 
@@ -34,7 +34,7 @@ function maybeCompose(maybeFn: any): TransformFunctions {
  * registry shape.
  */
 function cleanupTransformRegistry(
-  maybeRegistry: AssetTransformInit
+  maybeRegistry: AssetTransformInit,
 ): TransformRegistry {
   if (Array.isArray(maybeRegistry)) {
     const wrappedTransforms = maybeRegistry.map(([key, value]) => {
@@ -58,7 +58,7 @@ function cleanupTransformRegistry(
  * This allows users to embed stateful data into transforms.
  */
 export class AssetTransformPlugin implements PlayerPlugin {
-  name = 'asset-transform';
+  name = "asset-transform";
   public readonly registry: TransformRegistry;
 
   constructor(transforms: AssetTransformInit) {
@@ -68,7 +68,7 @@ export class AssetTransformPlugin implements PlayerPlugin {
   apply(player: Player) {
     player.hooks.viewController.tap(this.name, (vc) => {
       this.registry.forEach(({ key, value }) =>
-        vc.transformRegistry.set(key, maybeCompose(value))
+        vc.transformRegistry.set(key, maybeCompose(value)),
       );
     });
   }

package/src/propertiesToSkip.ts

@@ -1,4 +1,4 @@
-import type { BeforeTransformFunction } from '@player-ui/player';
+import type { BeforeTransformFunction } from "@player-ui/player";
 
 /**
  * Passes a property to the plugins.stringResolver.propertiesToSkip array or creates it if it doesn't exist
@@ -6,14 +6,14 @@ import type { BeforeTransformFunction } from '@player-ui/player';
  * @param asset - Asset to apply the transform to
  */
 export const propertiesToSkipTransform = (
-  parameters: string[]
+  parameters: string[],
 ): BeforeTransformFunction => {
   return (asset) => {
     const skipArray = asset.plugins?.stringResolver?.propertiesToSkip ?? [];
 
     /** makes sure there are no empty strings in the array */
     const parameterArray = parameters.filter((element) => {
-      return element !== '';
+      return element !== "";
     });
 
     if (parameterArray.length === 0) {

package/src/utils.ts

@@ -4,7 +4,7 @@ import type {
   BeforeTransformFunction,
   TransformFunction,
   TransformFunctions,
-} from '@player-ui/player';
+} from "@player-ui/player";
 
 function composeTransforms(
   ...args: TransformFunction<any>[]
@@ -65,7 +65,7 @@ export function compose(
   const resolveFns: TransformFunction<any>[] = [];
 
   for (const arg of args) {
-    if (typeof arg === 'function') {
+    if (typeof arg === "function") {
       resolveFns.push(arg);
     } else {
       if (arg?.resolve) {