@player-ui/reference-assets-plugin 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assetTransformPlugin = require('@player-ui/asset-transform-plugin');
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const inputTransform = (asset, options) => {
+  var _a, _b;
+  return __spreadProps$1(__spreadValues$1({}, asset), {
+    format(val) {
+      if (asset.binding === void 0) {
+        return val;
+      }
+      return options.data.format(asset.binding, val);
+    },
+    set(val) {
+      if (asset.binding === void 0) {
+        return;
+      }
+      return options.data.model.set([[asset.binding, val]], {
+        formatted: true
+      });
+    },
+    value: asset.binding === void 0 ? "" : options.data.model.get(asset.binding, {
+      includeInvalid: true,
+      formatted: true
+    }),
+    validation: asset.binding === void 0 ? void 0 : (_a = options.validation) == null ? void 0 : _a.get(asset.binding, { track: true }),
+    dataType: asset.binding === void 0 ? void 0 : (_b = options.validation) == null ? void 0 : _b.type(asset.binding)
+  });
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function isBackAction(action) {
+  return action.value === "Prev";
+}
+const transform = (action, options) => {
+  return __spreadProps(__spreadValues({}, action), {
+    run() {
+      var _a, _b;
+      if (action.exp) {
+        options.evaluate(action.exp);
+      }
+      if (action.value) {
+        const skipValidation = (_a = action.metaData) == null ? void 0 : _a.skipValidation;
+        (_b = options.transition) == null ? void 0 : _b.call(options, action.value, { force: skipValidation });
+      }
+    }
+  });
+};
+const expPropTransform = (asset) => {
+  var _a, _b, _c, _d, _e, _f;
+  const skipArray = (_b = (_a = asset.plugins) == null ? void 0 : _a.stringResolver) == null ? void 0 : _b.propertiesToSkip;
+  if (skipArray && skipArray.indexOf("exp") > 1) {
+    return asset;
+  }
+  return __spreadProps(__spreadValues({}, asset), {
+    plugins: __spreadProps(__spreadValues({}, asset.plugins), {
+      stringResolver: __spreadProps(__spreadValues({}, (_c = asset == null ? void 0 : asset.plugins) == null ? void 0 : _c.stringResolver), {
+        propertiesToSkip: [
+          ...(_f = (_e = (_d = asset.plugins) == null ? void 0 : _d.stringResolver) == null ? void 0 : _e.propertiesToSkip) != null ? _f : [],
+          "exp"
+        ]
+      })
+    })
+  });
+};
+const actionTransform = assetTransformPlugin.compose(transform, assetTransformPlugin.composeBefore(expPropTransform));
+
+class ReferenceAssetsPlugin {
+  constructor() {
+    this.name = "reference-assets-transforms";
+  }
+  apply(player) {
+    player.registerPlugin(new assetTransformPlugin.AssetTransformPlugin([
+      [{ type: "action" }, actionTransform],
+      [{ type: "input" }, inputTransform]
+    ]));
+  }
+}
+
+exports.ReferenceAssetsPlugin = ReferenceAssetsPlugin;
+exports.actionTransform = actionTransform;
+exports.expPropTransform = expPropTransform;
+exports.inputTransform = inputTransform;
+exports.isBackAction = isBackAction;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+import * as _player_ui_player from '@player-ui/player';
+import { Asset, AssetWrapper, Binding, ValidationResponse, Schema, TransformFunction, Expression, BeforeTransformFunction, PlayerPlugin, Player } from '@player-ui/player';
+import { BeaconDataType } from '@player-ui/beacon-plugin';
+
+/**
+ * This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+ * Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.
+ * */
+interface InputAsset<AnyTextAsset extends Asset = Asset> extends Asset<'input'> {
+    /** Asset container for a field label. */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** Asset container for a note. */
+    note?: AssetWrapper<AnyTextAsset>;
+    /** The location in the data-model to store the data */
+    binding: Binding;
+    /** Optional additional data */
+    metaData?: {
+        /** Additional data to beacon when this input changes */
+        beacon?: BeaconDataType;
+    };
+}
+declare type ValueType = string | undefined;
+interface TransformedInput extends InputAsset {
+    /** A function to commit the new value to the data-model */
+    set: (newValue: ValueType) => void;
+    /** A function to format a value */
+    format: (newValue: ValueType) => ValueType;
+    /** The current value of the input from the data-model */
+    value: ValueType;
+    /** Any validation associated with the current input's value */
+    validation?: ValidationResponse;
+    /** The dataType defined from the schema */
+    dataType?: Schema.DataType;
+}
+
+/**
+ * Docs about the asset transform
+ */
+declare const inputTransform: TransformFunction<InputAsset, TransformedInput>;
+
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+ */
+interface ActionAsset<AnyTextAsset extends Asset = Asset> extends Asset<'action'> {
+    /** The transition value of the action in the state machine */
+    value?: string;
+    /** A text-like asset for the action's label */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** An optional expression to execute before transitioning */
+    exp?: Expression;
+    /** An optional string that describes the action for screen-readers */
+    accessibility?: string;
+    /** Additional optional data to assist with the action interactions on the page */
+    metaData?: {
+        /** Additional data to beacon */
+        beacon?: BeaconDataType;
+        /** Force transition to the next view without checking for validation */
+        skipValidation?: boolean;
+    };
+}
+/** A stateful instance of an action */
+interface TransformedAction extends ActionAsset {
+    /** A method to execute the action */
+    run: () => void;
+}
+
+declare function isBackAction(action: ActionAsset): boolean;
+/**
+ * Appends `exp` to the plugins.stringResolver.propertiesToSkip array or creates it if it doesn't exist
+ *
+ * @param asset - Asset to apply the transform to
+ */
+declare const expPropTransform: BeforeTransformFunction<Asset>;
+declare const actionTransform: _player_ui_player.TransformFunctions;
+
+interface CollectionAsset extends Asset<'collection'> {
+    /** An optional label to title the collection */
+    label?: AssetWrapper;
+    /** The string value to show */
+    values?: Array<AssetWrapper>;
+}
+
+interface InfoAsset extends Asset<'info'> {
+    /** The string value to show */
+    title?: AssetWrapper;
+    /** subtitle */
+    subTitle?: AssetWrapper;
+    /** Primary place for info  */
+    primaryInfo?: AssetWrapper;
+    /** List of actions to show at the bottom of the page */
+    actions?: Array<AssetWrapper>;
+}
+
+interface TextAsset extends Asset<'text'> {
+    /** The text to display */
+    value: string;
+    /** Any modifiers on the text */
+    modifiers?: Array<TextModifier>;
+}
+declare type TextModifier = BasicTextModifier | LinkModifier;
+interface BasicTextModifier {
+    /** The modifier type */
+    type: string;
+    /** Modifiers can be named when used in strings */
+    name?: string;
+    /** A spot for other metaData or properties */
+    [key: string]: unknown;
+}
+/** A modifier to turn the text into a link */
+interface LinkModifier {
+    /** The link type denotes this as a link */
+    type: 'link';
+    /** An optional expression to run before the link is opened */
+    exp?: Expression;
+    /** metaData about the link's target */
+    metaData: {
+        /** The location of the link to load */
+        ref: string;
+        /** Used to indicate an application specific resolver to use */
+        'mime-type'?: string;
+    };
+}
+
+/**
+ * A plugin to add transforms for the reference assets
+ */
+declare class ReferenceAssetsPlugin implements PlayerPlugin {
+    name: string;
+    apply(player: Player): void;
+}
+
+export { ActionAsset, BasicTextModifier, CollectionAsset, InfoAsset, InputAsset, LinkModifier, ReferenceAssetsPlugin, TextAsset, TextModifier, TransformedAction, TransformedInput, actionTransform, expPropTransform, inputTransform, isBackAction };

package/dist/index.esm.js

@@ -0,0 +1,116 @@
+import { compose, composeBefore, AssetTransformPlugin } from '@player-ui/asset-transform-plugin';
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const inputTransform = (asset, options) => {
+  var _a, _b;
+  return __spreadProps$1(__spreadValues$1({}, asset), {
+    format(val) {
+      if (asset.binding === void 0) {
+        return val;
+      }
+      return options.data.format(asset.binding, val);
+    },
+    set(val) {
+      if (asset.binding === void 0) {
+        return;
+      }
+      return options.data.model.set([[asset.binding, val]], {
+        formatted: true
+      });
+    },
+    value: asset.binding === void 0 ? "" : options.data.model.get(asset.binding, {
+      includeInvalid: true,
+      formatted: true
+    }),
+    validation: asset.binding === void 0 ? void 0 : (_a = options.validation) == null ? void 0 : _a.get(asset.binding, { track: true }),
+    dataType: asset.binding === void 0 ? void 0 : (_b = options.validation) == null ? void 0 : _b.type(asset.binding)
+  });
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function isBackAction(action) {
+  return action.value === "Prev";
+}
+const transform = (action, options) => {
+  return __spreadProps(__spreadValues({}, action), {
+    run() {
+      var _a, _b;
+      if (action.exp) {
+        options.evaluate(action.exp);
+      }
+      if (action.value) {
+        const skipValidation = (_a = action.metaData) == null ? void 0 : _a.skipValidation;
+        (_b = options.transition) == null ? void 0 : _b.call(options, action.value, { force: skipValidation });
+      }
+    }
+  });
+};
+const expPropTransform = (asset) => {
+  var _a, _b, _c, _d, _e, _f;
+  const skipArray = (_b = (_a = asset.plugins) == null ? void 0 : _a.stringResolver) == null ? void 0 : _b.propertiesToSkip;
+  if (skipArray && skipArray.indexOf("exp") > 1) {
+    return asset;
+  }
+  return __spreadProps(__spreadValues({}, asset), {
+    plugins: __spreadProps(__spreadValues({}, asset.plugins), {
+      stringResolver: __spreadProps(__spreadValues({}, (_c = asset == null ? void 0 : asset.plugins) == null ? void 0 : _c.stringResolver), {
+        propertiesToSkip: [
+          ...(_f = (_e = (_d = asset.plugins) == null ? void 0 : _d.stringResolver) == null ? void 0 : _e.propertiesToSkip) != null ? _f : [],
+          "exp"
+        ]
+      })
+    })
+  });
+};
+const actionTransform = compose(transform, composeBefore(expPropTransform));
+
+class ReferenceAssetsPlugin {
+  constructor() {
+    this.name = "reference-assets-transforms";
+  }
+  apply(player) {
+    player.registerPlugin(new AssetTransformPlugin([
+      [{ type: "action" }, actionTransform],
+      [{ type: "input" }, inputTransform]
+    ]));
+  }
+}
+
+export { ReferenceAssetsPlugin, actionTransform, expPropTransform, inputTransform, isBackAction };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@player-ui/reference-assets-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/binding-grammar": "0.0.1-next.1",
+    "@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/assets/action/index.ts

@@ -0,0 +1,2 @@
+export * from './transform';
+export * from './types';

package/src/assets/action/transform.ts

@@ -0,0 +1,65 @@
+import type {
+  Asset,
+  TransformFunction,
+  BeforeTransformFunction,
+} from '@player-ui/player';
+import { compose, composeBefore } from '@player-ui/asset-transform-plugin';
+import type { ActionAsset, TransformedAction } from './types';
+
+export function isBackAction(action: ActionAsset): boolean {
+  return action.value === 'Prev';
+}
+
+/**
+ * Attaches the methods to execute an action to an action
+ */
+const transform: TransformFunction<ActionAsset, TransformedAction> = (
+  action,
+  options
+) => {
+  return {
+    ...action,
+    run() {
+      if (action.exp) {
+        options.evaluate(action.exp);
+      }
+
+      if (action.value) {
+        const skipValidation = action.metaData?.skipValidation;
+        options.transition?.(action.value, { force: skipValidation });
+      }
+    },
+  };
+};
+
+/**
+ * Appends `exp` to the plugins.stringResolver.propertiesToSkip array or creates it if it doesn't exist
+ *
+ * @param asset - Asset to apply the transform to
+ */
+export const expPropTransform: BeforeTransformFunction<Asset> = (asset) => {
+  const skipArray = asset.plugins?.stringResolver?.propertiesToSkip;
+
+  if (skipArray && skipArray.indexOf('exp') > 1) {
+    return asset;
+  }
+
+  return {
+    ...asset,
+    plugins: {
+      ...asset.plugins,
+      stringResolver: {
+        ...asset?.plugins?.stringResolver,
+        propertiesToSkip: [
+          ...(asset.plugins?.stringResolver?.propertiesToSkip ?? []),
+          'exp',
+        ],
+      },
+    },
+  };
+};
+
+export const actionTransform = compose(
+  transform,
+  composeBefore(expPropTransform)
+);

package/src/assets/action/types.ts

@@ -0,0 +1,37 @@
+import type { Asset, AssetWrapper, Expression } from '@player-ui/player';
+import type { BeaconDataType } from '@player-ui/beacon-plugin';
+
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+ */
+export interface ActionAsset<AnyTextAsset extends Asset = Asset>
+  extends Asset<'action'> {
+  /** The transition value of the action in the state machine */
+  value?: string;
+
+  /** A text-like asset for the action's label */
+  label?: AssetWrapper<AnyTextAsset>;
+
+  /** An optional expression to execute before transitioning */
+  exp?: Expression;
+
+  /** An optional string that describes the action for screen-readers */
+  accessibility?: string;
+
+  /** Additional optional data to assist with the action interactions on the page */
+  metaData?: {
+    /** Additional data to beacon */
+    beacon?: BeaconDataType;
+
+    /** Force transition to the next view without checking for validation */
+    skipValidation?: boolean;
+  };
+}
+
+/** A stateful instance of an action */
+export interface TransformedAction extends ActionAsset {
+  /** A method to execute the action */
+  run: () => void;
+}

package/src/assets/collection/index.ts

@@ -0,0 +1 @@
+export * from './types';

package/src/assets/collection/types.ts

@@ -0,0 +1,8 @@
+import type { AssetWrapper, Asset } from '@player-ui/player';
+
+export interface CollectionAsset extends Asset<'collection'> {
+  /** An optional label to title the collection */
+  label?: AssetWrapper;
+  /** The string value to show */
+  values?: Array<AssetWrapper>;
+}

package/src/assets/index.ts

@@ -0,0 +1,5 @@
+export * from './input';
+export * from './action';
+export * from './collection';
+export * from './info';
+export * from './text';

package/src/assets/info/index.ts

@@ -0,0 +1 @@
+export * from './types';

package/src/assets/info/types.ts

@@ -0,0 +1,15 @@
+import type { AssetWrapper, Asset } from '@player-ui/player';
+
+export interface InfoAsset extends Asset<'info'> {
+  /** The string value to show */
+  title?: AssetWrapper;
+
+  /** subtitle */
+  subTitle?: AssetWrapper;
+
+  /** Primary place for info  */
+  primaryInfo?: AssetWrapper;
+
+  /** List of actions to show at the bottom of the page */
+  actions?: Array<AssetWrapper>;
+}

package/src/assets/input/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './transform';

package/src/assets/input/transform.ts

@@ -0,0 +1,45 @@
+import type { TransformFunction } from '@player-ui/player';
+import type { InputAsset, TransformedInput } from './types';
+
+/**
+ * Docs about the asset transform
+ */
+export const inputTransform: TransformFunction<InputAsset, TransformedInput> = (
+  asset,
+  options
+) => {
+  return {
+    ...asset,
+    format(val) {
+      if (asset.binding === undefined) {
+        return val;
+      }
+
+      return options.data.format(asset.binding, val);
+    },
+    set(val) {
+      if (asset.binding === undefined) {
+        return;
+      }
+
+      return options.data.model.set([[asset.binding, val]], {
+        formatted: true,
+      });
+    },
+    value:
+      asset.binding === undefined
+        ? ''
+        : options.data.model.get(asset.binding, {
+            includeInvalid: true,
+            formatted: true,
+          }),
+    validation:
+      asset.binding === undefined
+        ? undefined
+        : options.validation?.get(asset.binding, { track: true }),
+    dataType:
+      asset.binding === undefined
+        ? undefined
+        : options.validation?.type(asset.binding),
+  };
+};

package/src/assets/input/types.ts

@@ -0,0 +1,49 @@
+import type {
+  Asset,
+  AssetWrapper,
+  Schema,
+  Binding,
+  ValidationResponse,
+} from '@player-ui/player';
+import type { BeaconDataType } from '@player-ui/beacon-plugin';
+
+/**
+ * This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+ * Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.
+ * */
+export interface InputAsset<AnyTextAsset extends Asset = Asset>
+  extends Asset<'input'> {
+  /** Asset container for a field label. */
+  label?: AssetWrapper<AnyTextAsset>;
+
+  /** Asset container for a note. */
+  note?: AssetWrapper<AnyTextAsset>;
+
+  /** The location in the data-model to store the data */
+  binding: Binding;
+
+  /** Optional additional data */
+  metaData?: {
+    /** Additional data to beacon when this input changes */
+    beacon?: BeaconDataType;
+  };
+}
+
+type ValueType = string | undefined;
+
+export interface TransformedInput extends InputAsset {
+  /** A function to commit the new value to the data-model */
+  set: (newValue: ValueType) => void;
+
+  /** A function to format a value */
+  format: (newValue: ValueType) => ValueType;
+
+  /** The current value of the input from the data-model */
+  value: ValueType;
+
+  /** Any validation associated with the current input's value */
+  validation?: ValidationResponse;
+
+  /** The dataType defined from the schema */
+  dataType?: Schema.DataType;
+}

package/src/assets/text/index.ts

@@ -0,0 +1 @@
+export * from './types';

package/src/assets/text/types.ts

@@ -0,0 +1,40 @@
+import type { Asset, Expression } from '@player-ui/player';
+
+export interface TextAsset extends Asset<'text'> {
+  /** The text to display */
+  value: string;
+
+  /** Any modifiers on the text */
+  modifiers?: Array<TextModifier>;
+}
+
+export type TextModifier = BasicTextModifier | LinkModifier;
+
+export interface BasicTextModifier {
+  /** The modifier type */
+  type: string;
+
+  /** Modifiers can be named when used in strings */
+  name?: string;
+
+  /** A spot for other metaData or properties */
+  [key: string]: unknown;
+}
+
+/** A modifier to turn the text into a link */
+export interface LinkModifier {
+  /** The link type denotes this as a link */
+  type: 'link';
+
+  /** An optional expression to run before the link is opened */
+  exp?: Expression;
+
+  /** metaData about the link's target */
+  metaData: {
+    /** The location of the link to load */
+    ref: string;
+
+    /** Used to indicate an application specific resolver to use */
+    'mime-type'?: string;
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './assets';
+export * from './plugin';

package/src/plugin.ts

@@ -0,0 +1,19 @@
+import type { Player, PlayerPlugin } from '@player-ui/player';
+import { AssetTransformPlugin } from '@player-ui/asset-transform-plugin';
+import { inputTransform, actionTransform } from './assets';
+
+/**
+ * A plugin to add transforms for the reference assets
+ */
+export class ReferenceAssetsPlugin implements PlayerPlugin {
+  name = 'reference-assets-transforms';
+
+  apply(player: Player) {
+    player.registerPlugin(
+      new AssetTransformPlugin([
+        [{ type: 'action' }, actionTransform],
+        [{ type: 'input' }, inputTransform],
+      ])
+    );
+  }
+}