@player-ui/asset-transform-plugin 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var partialMatchRegistry = require('@player-ui/partial-match-registry');
+
+function composeTransforms(...args) {
+  const [fn, ...fns] = args.reverse();
+  return (asset, options, store) => {
+    const value = fn(asset, options, store);
+    if (!fns.length) {
+      return value;
+    }
+    return fns.reduce((prevValue, current) => {
+      return current(prevValue, options, store);
+    }, value);
+  };
+}
+function composeBefore(...args) {
+  return {
+    beforeResolve: composeTransforms(...args)
+  };
+}
+function compose(...args) {
+  const beforeResolveFns = [];
+  const resolveFns = [];
+  for (const arg of args) {
+    if (typeof arg === "function") {
+      resolveFns.push(arg);
+    } else {
+      if (arg == null ? void 0 : arg.resolve) {
+        resolveFns.push(arg.resolve);
+      }
+      if (arg == null ? void 0 : arg.beforeResolve) {
+        beforeResolveFns.push(arg.beforeResolve);
+      }
+    }
+  }
+  return {
+    beforeResolve: beforeResolveFns.length ? composeTransforms(...beforeResolveFns) : void 0,
+    resolve: resolveFns.length ? composeTransforms(...resolveFns) : void 0
+  };
+}
+
+function maybeCompose(maybeFn) {
+  if (typeof maybeFn === "object") {
+    return maybeFn;
+  }
+  return compose(maybeFn);
+}
+function cleanupTransformRegistry(maybeRegistry) {
+  if (Array.isArray(maybeRegistry)) {
+    const wrappedTransforms = maybeRegistry.map(([key, value]) => {
+      return [key, maybeCompose(value)];
+    });
+    return new partialMatchRegistry.Registry(wrappedTransforms);
+  }
+  const registry = new partialMatchRegistry.Registry();
+  maybeRegistry.forEach(({ key, value }) => {
+    registry.set(key, maybeCompose(value));
+  });
+  return registry;
+}
+class AssetTransformPlugin {
+  constructor(transforms) {
+    this.name = "asset-transform";
+    this.registry = cleanupTransformRegistry(transforms);
+  }
+  apply(player) {
+    player.hooks.viewController.tap(this.name, (vc) => {
+      this.registry.forEach(({ key, value }) => vc.transformRegistry.set(key, maybeCompose(value)));
+    });
+  }
+}
+
+exports.AssetTransformPlugin = AssetTransformPlugin;
+exports.compose = compose;
+exports.composeBefore = composeBefore;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { BeforeTransformFunction, TransformFunctions, TransformFunction, PlayerPlugin, TransformRegistry, Player } from '@player-ui/player';
+import { Registry } from '@player-ui/partial-match-registry';
+
+/**
+ * Helper function to make it easier to create transforms that need to be ran in
+ * the `beforeResolve` hook. Just like `compose`, functions are evaluated from
+ * right-to-left.
+ */
+declare function composeBefore(...args: BeforeTransformFunction<any>[]): TransformFunctions;
+/**
+ * Performs right-to-left function evaluation of each transform function. Unlike
+ * other compose functions, this does not require unary arguments for all but the
+ * last function. The value returned from each function will be used as the value
+ * for the next function.
+ */
+declare function compose(...args: Array<TransformFunction<any> | TransformFunctions>): TransformFunctions;
+
+declare type TransformType = TransformFunction<any> | TransformFunctions;
+declare type TransformRegistryEntries = Array<[any, TransformType]>;
+declare type AssetTransformInit = Registry<TransformType> | TransformRegistryEntries;
+/**
+ * A plugin to register custom transforms on certain asset types
+ * This allows users to embed stateful data into transforms.
+ */
+declare class AssetTransformPlugin implements PlayerPlugin {
+    name: string;
+    readonly registry: TransformRegistry;
+    constructor(transforms: AssetTransformInit);
+    apply(player: Player): void;
+}
+
+export { AssetTransformInit, AssetTransformPlugin, TransformRegistryEntries, TransformType, compose, composeBefore };

package/dist/index.esm.js

@@ -0,0 +1,73 @@
+import { Registry } from '@player-ui/partial-match-registry';
+
+function composeTransforms(...args) {
+  const [fn, ...fns] = args.reverse();
+  return (asset, options, store) => {
+    const value = fn(asset, options, store);
+    if (!fns.length) {
+      return value;
+    }
+    return fns.reduce((prevValue, current) => {
+      return current(prevValue, options, store);
+    }, value);
+  };
+}
+function composeBefore(...args) {
+  return {
+    beforeResolve: composeTransforms(...args)
+  };
+}
+function compose(...args) {
+  const beforeResolveFns = [];
+  const resolveFns = [];
+  for (const arg of args) {
+    if (typeof arg === "function") {
+      resolveFns.push(arg);
+    } else {
+      if (arg == null ? void 0 : arg.resolve) {
+        resolveFns.push(arg.resolve);
+      }
+      if (arg == null ? void 0 : arg.beforeResolve) {
+        beforeResolveFns.push(arg.beforeResolve);
+      }
+    }
+  }
+  return {
+    beforeResolve: beforeResolveFns.length ? composeTransforms(...beforeResolveFns) : void 0,
+    resolve: resolveFns.length ? composeTransforms(...resolveFns) : void 0
+  };
+}
+
+function maybeCompose(maybeFn) {
+  if (typeof maybeFn === "object") {
+    return maybeFn;
+  }
+  return compose(maybeFn);
+}
+function cleanupTransformRegistry(maybeRegistry) {
+  if (Array.isArray(maybeRegistry)) {
+    const wrappedTransforms = maybeRegistry.map(([key, value]) => {
+      return [key, maybeCompose(value)];
+    });
+    return new Registry(wrappedTransforms);
+  }
+  const registry = new Registry();
+  maybeRegistry.forEach(({ key, value }) => {
+    registry.set(key, maybeCompose(value));
+  });
+  return registry;
+}
+class AssetTransformPlugin {
+  constructor(transforms) {
+    this.name = "asset-transform";
+    this.registry = cleanupTransformRegistry(transforms);
+  }
+  apply(player) {
+    player.hooks.viewController.tap(this.name, (vc) => {
+      this.registry.forEach(({ key, value }) => vc.transformRegistry.set(key, maybeCompose(value)));
+    });
+  }
+}
+
+export { AssetTransformPlugin, compose, composeBefore };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@player-ui/asset-transform-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",
+    "@player-ui/types": "0.0.1-next.1"
+  },
+  "dependencies": {
+    "@player-ui/partial-match-registry": "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/index.ts

@@ -0,0 +1,73 @@
+import type {
+  Player,
+  PlayerPlugin,
+  TransformRegistry,
+  TransformFunction,
+  TransformFunctions,
+} from '@player-ui/player';
+import { Registry } from '@player-ui/partial-match-registry';
+import { compose } from './utils';
+
+export * from './utils';
+export type TransformType = TransformFunction<any> | TransformFunctions;
+export type TransformRegistryEntries = Array<[any, TransformType]>;
+export type AssetTransformInit =
+  | Registry<TransformType>
+  | TransformRegistryEntries;
+
+/**
+ * Normalize asset transform values so that they are all objects that contains
+ * the resolve & beforeResolve functions.
+ */
+function maybeCompose(maybeFn: any): TransformFunctions {
+  if (typeof maybeFn === 'object') {
+    return maybeFn;
+  }
+
+  return compose(maybeFn);
+}
+
+/**
+ * Standardize each variation of Asset Registry input into the same transform
+ * registry shape.
+ */
+function cleanupTransformRegistry(
+  maybeRegistry: AssetTransformInit
+): TransformRegistry {
+  if (Array.isArray(maybeRegistry)) {
+    const wrappedTransforms = maybeRegistry.map(([key, value]) => {
+      return [key, maybeCompose(value)] as [any, TransformFunctions];
+    });
+
+    return new Registry(wrappedTransforms);
+  }
+
+  const registry = new Registry<TransformFunctions>();
+
+  maybeRegistry.forEach(({ key, value }) => {
+    registry.set(key, maybeCompose(value));
+  });
+
+  return registry;
+}
+
+/**
+ * A plugin to register custom transforms on certain asset types
+ * This allows users to embed stateful data into transforms.
+ */
+export class AssetTransformPlugin implements PlayerPlugin {
+  name = 'asset-transform';
+  public readonly registry: TransformRegistry;
+
+  constructor(transforms: AssetTransformInit) {
+    this.registry = cleanupTransformRegistry(transforms);
+  }
+
+  apply(player: Player) {
+    player.hooks.viewController.tap(this.name, (vc) => {
+      this.registry.forEach(({ key, value }) =>
+        vc.transformRegistry.set(key, maybeCompose(value))
+      );
+    });
+  }
+}

package/src/utils.ts

@@ -0,0 +1,87 @@
+import type { Resolve } from '@player-ui/view';
+import type {
+  Store,
+  BeforeTransformFunction,
+  TransformFunction,
+  TransformFunctions,
+} from '@player-ui/player';
+
+function composeTransforms(
+  ...args: TransformFunction<any>[]
+): TransformFunction<any>;
+
+function composeTransforms(
+  ...args: BeforeTransformFunction<any>[]
+): BeforeTransformFunction<any>;
+
+/**
+ * More closely resembles the `compose` function you may have used. Performs
+ * right-to-left function evaluation, but leveraging the common signature for
+ * Transform Functions. The `options` and `store` is unchanging for each
+ * transform since only `value` is returned, allowing them to safely be passed
+ * into each transform.
+ */
+function composeTransforms(
+  ...args: TransformFunction<any>[] | BeforeTransformFunction<any>[]
+): TransformFunction<any> | BeforeTransformFunction<any> {
+  const [fn, ...fns] = args.reverse();
+
+  return (asset: any, options: Resolve.NodeResolveOptions, store: Store) => {
+    const value = fn(asset, options, store);
+
+    if (!fns.length) {
+      return value;
+    }
+
+    return fns.reduce((prevValue, current) => {
+      return current(prevValue, options, store);
+    }, value);
+  };
+}
+
+/**
+ * Helper function to make it easier to create transforms that need to be ran in
+ * the `beforeResolve` hook. Just like `compose`, functions are evaluated from
+ * right-to-left.
+ */
+export function composeBefore(
+  ...args: BeforeTransformFunction<any>[]
+): TransformFunctions {
+  return {
+    beforeResolve: composeTransforms(...args),
+  };
+}
+
+/**
+ * Performs right-to-left function evaluation of each transform function. Unlike
+ * other compose functions, this does not require unary arguments for all but the
+ * last function. The value returned from each function will be used as the value
+ * for the next function.
+ */
+export function compose(
+  ...args: Array<TransformFunction<any> | TransformFunctions>
+): TransformFunctions {
+  const beforeResolveFns: BeforeTransformFunction<any>[] = [];
+  const resolveFns: TransformFunction<any>[] = [];
+
+  for (const arg of args) {
+    if (typeof arg === 'function') {
+      resolveFns.push(arg);
+    } else {
+      if (arg?.resolve) {
+        resolveFns.push(arg.resolve);
+      }
+
+      if (arg?.beforeResolve) {
+        beforeResolveFns.push(arg.beforeResolve);
+      }
+    }
+  }
+
+  return {
+    beforeResolve: beforeResolveFns.length
+      ? composeTransforms(...beforeResolveFns)
+      : undefined,
+    resolve: resolveFns.length ? composeTransforms(...resolveFns) : undefined,
+  };
+}