@player-ui/computed-properties-plugin 0.7.4-next.4 → 0.7.5--canary.434.14868

package/dist/ComputedPropertiesPlugin.native.js

@@ -0,0 +1,182 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var ComputedPropertiesPlugin = function() {
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = function(target, all) {
+        for(var name in all)__defProp(target, name, {
+            get: all[name],
+            enumerable: true
+        });
+    };
+    var __copyProps = function(to, from, except, desc) {
+        if (from && typeof from === "object" || typeof from === "function") {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                var _loop = function() {
+                    var key = _step.value;
+                    if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                        get: function() {
+                            return from[key];
+                        },
+                        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                    });
+                };
+                for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        return to;
+    };
+    var __toCommonJS = function(mod) {
+        return __copyProps(__defProp({}, "__esModule", {
+            value: true
+        }), mod);
+    };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts
+    var src_exports = {};
+    __export(src_exports, {
+        ComputedPropertiesPlugin: function() {
+            return ComputedPropertiesPlugin;
+        }
+    });
+    var ComputedPropertiesPlugin = /*#__PURE__*/ function() {
+        function ComputedPropertiesPlugin() {
+            _class_call_check(this, ComputedPropertiesPlugin);
+            this.name = "ComputedProperties";
+        }
+        _create_class(ComputedPropertiesPlugin, [
+            {
+                key: "apply",
+                value: function apply(player) {
+                    var _this = this;
+                    var schemaController;
+                    var expressionEvaluator;
+                    var getExpressionType = function(binding) {
+                        var dataType = schemaController === null || schemaController === void 0 ? void 0 : schemaController.getType(binding);
+                        if ((dataType === null || dataType === void 0 ? void 0 : dataType.type) === "Expression") {
+                            return dataType;
+                        }
+                    };
+                    var computedPropertyMiddleware = {
+                        name: this.name,
+                        get: function get(binding, options, next) {
+                            var expType = getExpressionType(binding);
+                            if (expType) {
+                                var exp = expType.exp;
+                                var result = exp && (expressionEvaluator === null || expressionEvaluator === void 0 ? void 0 : expressionEvaluator.evaluate(exp, options === null || options === void 0 ? void 0 : options.context));
+                                return result !== null && result !== void 0 ? result : expType.default;
+                            }
+                            return next === null || next === void 0 ? void 0 : next.get(binding, options);
+                        },
+                        set: function set(transaction, options, next) {
+                            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(var _iterator = transaction[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    var setOperation = _step.value;
+                                    if (getExpressionType(setOperation[0])) {
+                                        throw new Error("Invalid 'set' operation on computed property: ".concat(setOperation[0].asString()));
+                                    }
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
+                            var _next_set;
+                            return (_next_set = next === null || next === void 0 ? void 0 : next.set(transaction, options)) !== null && _next_set !== void 0 ? _next_set : [];
+                        },
+                        delete: function _delete(binding, options, next) {
+                            if (getExpressionType(binding)) {
+                                throw new Error("Invalid 'delete' operation on computed property: ".concat(binding.asString()));
+                            }
+                            return next === null || next === void 0 ? void 0 : next.delete(binding, options);
+                        }
+                    };
+                    player.hooks.dataController.tap(this.name, function(dataController) {
+                        dataController.hooks.resolveDataStages.tap(_this.name, function(dataPipeline) {
+                            return _to_consumable_array(dataPipeline).concat([
+                                computedPropertyMiddleware
+                            ]);
+                        });
+                    });
+                    player.hooks.schema.tap(this.name, function(schema) {
+                        schemaController = schema;
+                    });
+                    player.hooks.expressionEvaluator.tap(this.name, function(evaluator) {
+                        expressionEvaluator = evaluator;
+                    });
+                }
+            }
+        ]);
+        return ComputedPropertiesPlugin;
+    }();
+    return __toCommonJS(src_exports);
+}();
+//# sourceMappingURL=index.global.js.map

package/dist/ComputedPropertiesPlugin.native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAqBO,MAAM,2BAAN,MAAuD;AAAA,IAAvD;AACL,kBAAO;AAAA;AAAA,IAEP,MAAM,QAAgB;AAIpB,UAAI;AACJ,UAAI;AAGJ,YAAM,oBAAoB,CACxB,YACmC;AAEnC,cAAM,WAAW,kBAAkB,QAAQ,OAAO;AAElD,YAAI,UAAU,SAAS,cAAc;AACnC,iBAAO;AAAA,QACT;AAAA,MACF;AAEA,YAAM,6BAAkD;AAAA,QACtD,MAAM,KAAK;AAAA,QACX,IAAI,SAAS,SAAS,MAAM;AAC1B,gBAAM,UAAU,kBAAkB,OAAO;AAEzC,cAAI,SAAS;AACX,kBAAM,EAAE,IAAI,IAAI;AAChB,kBAAM,SACJ,OAAO,qBAAqB,SAAS,KAAK,SAAS,OAAO;AAE5D,mBAAO,UAAU,QAAQ;AAAA,UAC3B;AAEA,iBAAO,MAAM,IAAI,SAAS,OAAO;AAAA,QACnC;AAAA,QACA,IAAI,aAAa,SAAS,MAAe;AACvC,qBAAW,gBAAgB,aAAa;AACtC,gBAAI,kBAAkB,aAAa,CAAC,CAAC,GAAG;AACtC,oBAAM,IAAI;AAAA,gBACR,iDAAiD,aAAa,CAAC,EAAE,SAAS,CAAC;AAAA,cAC7E;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,MAAM,IAAI,aAAa,OAAO,KAAK,CAAC;AAAA,QAC7C;AAAA,QACA,OAAO,SAAS,SAAS,MAAM;AAC7B,cAAI,kBAAkB,OAAO,GAAG;AAC9B,kBAAM,IAAI;AAAA,cACR,oDAAoD,QAAQ,SAAS,CAAC;AAAA,YACxE;AAAA,UACF;AAEA,iBAAO,MAAM,OAAO,SAAS,OAAO;AAAA,QACtC;AAAA,MACF;AAEA,aAAO,MAAM,eAAe,IAAI,KAAK,MAAM,CAAC,mBAAmB;AAC7D,uBAAe,MAAM,kBAAkB,IAAI,KAAK,MAAM,CAAC,iBAAiB;AACtE,iBAAO,CAAC,GAAG,cAAc,0BAA0B;AAAA,QACrD,CAAC;AAAA,MACH,CAAC;AAED,aAAO,MAAM,OAAO,IAAI,KAAK,MAAM,CAAC,WAAW;AAC7C,2BAAmB;AAAA,MACrB,CAAC;AAED,aAAO,MAAM,oBAAoB,IAAI,KAAK,MAAM,CAAC,cAAc;AAC7D,8BAAsB;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,EACF","sourcesContent":["import type {\n  Player,\n  PlayerPlugin,\n  ExpressionEvaluator,\n  Schema,\n  Expression,\n  DataModelMiddleware,\n  Updates,\n  SchemaController,\n  BindingInstance,\n} from \"@player-ui/player\";\n\nexport interface ExpressionDataType extends Schema.DataType<\"Expression\"> {\n  /** The expression to evaluate to compute the value of this node */\n  exp?: Expression;\n}\n\n/**\n * A player plugin to manage beacon events.\n * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.\n */\nexport class ComputedPropertiesPlugin implements PlayerPlugin {\n  name = \"ComputedProperties\";\n\n  apply(player: Player) {\n    // Inject a middleware into the data-model to intercept any calls to an expression type in the schema\n    // Calls to `set` throw an error. Calls to `get` compute the value and return if or default\n\n    let schemaController: SchemaController | undefined;\n    let expressionEvaluator: ExpressionEvaluator | undefined;\n\n    /** Look up the data-type of the binding, and check for an Expression type */\n    const getExpressionType = (\n      binding: BindingInstance,\n    ): ExpressionDataType | undefined => {\n      // Check to see if the data-type of the binding is an `Expression`\n      const dataType = schemaController?.getType(binding);\n\n      if (dataType?.type === \"Expression\") {\n        return dataType as ExpressionDataType;\n      }\n    };\n\n    const computedPropertyMiddleware: DataModelMiddleware = {\n      name: this.name,\n      get(binding, options, next) {\n        const expType = getExpressionType(binding);\n\n        if (expType) {\n          const { exp } = expType;\n          const result =\n            exp && expressionEvaluator?.evaluate(exp, options?.context);\n\n          return result ?? expType.default;\n        }\n\n        return next?.get(binding, options);\n      },\n      set(transaction, options, next): Updates {\n        for (const setOperation of transaction) {\n          if (getExpressionType(setOperation[0])) {\n            throw new Error(\n              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`,\n            );\n          }\n        }\n\n        return next?.set(transaction, options) ?? [];\n      },\n      delete(binding, options, next) {\n        if (getExpressionType(binding)) {\n          throw new Error(\n            `Invalid 'delete' operation on computed property: ${binding.asString()}`,\n          );\n        }\n\n        return next?.delete(binding, options);\n      },\n    };\n\n    player.hooks.dataController.tap(this.name, (dataController) => {\n      dataController.hooks.resolveDataStages.tap(this.name, (dataPipeline) => {\n        return [...dataPipeline, computedPropertyMiddleware];\n      });\n    });\n\n    player.hooks.schema.tap(this.name, (schema) => {\n      schemaController = schema;\n    });\n\n    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {\n      expressionEvaluator = evaluator;\n    });\n  }\n}\n"]}

package/dist/cjs/index.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ComputedPropertiesPlugin: () => ComputedPropertiesPlugin
+});
+module.exports = __toCommonJS(src_exports);
+var ComputedPropertiesPlugin = class {
+  constructor() {
+    this.name = "ComputedProperties";
+  }
+  apply(player) {
+    let schemaController;
+    let expressionEvaluator;
+    const getExpressionType = (binding) => {
+      const dataType = schemaController?.getType(binding);
+      if (dataType?.type === "Expression") {
+        return dataType;
+      }
+    };
+    const computedPropertyMiddleware = {
+      name: this.name,
+      get(binding, options, next) {
+        const expType = getExpressionType(binding);
+        if (expType) {
+          const { exp } = expType;
+          const result = exp && expressionEvaluator?.evaluate(exp, options?.context);
+          return result ?? expType.default;
+        }
+        return next?.get(binding, options);
+      },
+      set(transaction, options, next) {
+        for (const setOperation of transaction) {
+          if (getExpressionType(setOperation[0])) {
+            throw new Error(
+              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`
+            );
+          }
+        }
+        return next?.set(transaction, options) ?? [];
+      },
+      delete(binding, options, next) {
+        if (getExpressionType(binding)) {
+          throw new Error(
+            `Invalid 'delete' operation on computed property: ${binding.asString()}`
+          );
+        }
+        return next?.delete(binding, options);
+      }
+    };
+    player.hooks.dataController.tap(this.name, (dataController) => {
+      dataController.hooks.resolveDataStages.tap(this.name, (dataPipeline) => {
+        return [...dataPipeline, computedPropertyMiddleware];
+      });
+    });
+    player.hooks.schema.tap(this.name, (schema) => {
+      schemaController = schema;
+    });
+    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {
+      expressionEvaluator = evaluator;
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComputedPropertiesPlugin
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts"],"sourcesContent":["import type {\n  Player,\n  PlayerPlugin,\n  ExpressionEvaluator,\n  Schema,\n  Expression,\n  DataModelMiddleware,\n  Updates,\n  SchemaController,\n  BindingInstance,\n} from \"@player-ui/player\";\n\nexport interface ExpressionDataType extends Schema.DataType<\"Expression\"> {\n  /** The expression to evaluate to compute the value of this node */\n  exp?: Expression;\n}\n\n/**\n * A player plugin to manage beacon events.\n * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.\n */\nexport class ComputedPropertiesPlugin implements PlayerPlugin {\n  name = \"ComputedProperties\";\n\n  apply(player: Player) {\n    // Inject a middleware into the data-model to intercept any calls to an expression type in the schema\n    // Calls to `set` throw an error. Calls to `get` compute the value and return if or default\n\n    let schemaController: SchemaController | undefined;\n    let expressionEvaluator: ExpressionEvaluator | undefined;\n\n    /** Look up the data-type of the binding, and check for an Expression type */\n    const getExpressionType = (\n      binding: BindingInstance,\n    ): ExpressionDataType | undefined => {\n      // Check to see if the data-type of the binding is an `Expression`\n      const dataType = schemaController?.getType(binding);\n\n      if (dataType?.type === \"Expression\") {\n        return dataType as ExpressionDataType;\n      }\n    };\n\n    const computedPropertyMiddleware: DataModelMiddleware = {\n      name: this.name,\n      get(binding, options, next) {\n        const expType = getExpressionType(binding);\n\n        if (expType) {\n          const { exp } = expType;\n          const result =\n            exp && expressionEvaluator?.evaluate(exp, options?.context);\n\n          return result ?? expType.default;\n        }\n\n        return next?.get(binding, options);\n      },\n      set(transaction, options, next): Updates {\n        for (const setOperation of transaction) {\n          if (getExpressionType(setOperation[0])) {\n            throw new Error(\n              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`,\n            );\n          }\n        }\n\n        return next?.set(transaction, options) ?? [];\n      },\n      delete(binding, options, next) {\n        if (getExpressionType(binding)) {\n          throw new Error(\n            `Invalid 'delete' operation on computed property: ${binding.asString()}`,\n          );\n        }\n\n        return next?.delete(binding, options);\n      },\n    };\n\n    player.hooks.dataController.tap(this.name, (dataController) => {\n      dataController.hooks.resolveDataStages.tap(this.name, (dataPipeline) => {\n        return [...dataPipeline, computedPropertyMiddleware];\n      });\n    });\n\n    player.hooks.schema.tap(this.name, (schema) => {\n      schemaController = schema;\n    });\n\n    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {\n      expressionEvaluator = evaluator;\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,IAAM,2BAAN,MAAuD;AAAA,EAAvD;AACL,gBAAO;AAAA;AAAA,EAEP,MAAM,QAAgB;AAIpB,QAAI;AACJ,QAAI;AAGJ,UAAM,oBAAoB,CACxB,YACmC;AAEnC,YAAM,WAAW,kBAAkB,QAAQ,OAAO;AAElD,UAAI,UAAU,SAAS,cAAc;AACnC,eAAO;AAAA,MACT;AAAA,IACF;AAEA,UAAM,6BAAkD;AAAA,MACtD,MAAM,KAAK;AAAA,MACX,IAAI,SAAS,SAAS,MAAM;AAC1B,cAAM,UAAU,kBAAkB,OAAO;AAEzC,YAAI,SAAS;AACX,gBAAM,EAAE,IAAI,IAAI;AAChB,gBAAM,SACJ,OAAO,qBAAqB,SAAS,KAAK,SAAS,OAAO;AAE5D,iBAAO,UAAU,QAAQ;AAAA,QAC3B;AAEA,eAAO,MAAM,IAAI,SAAS,OAAO;AAAA,MACnC;AAAA,MACA,IAAI,aAAa,SAAS,MAAe;AACvC,mBAAW,gBAAgB,aAAa;AACtC,cAAI,kBAAkB,aAAa,CAAC,CAAC,GAAG;AACtC,kBAAM,IAAI;AAAA,cACR,iDAAiD,aAAa,CAAC,EAAE,SAAS,CAAC;AAAA,YAC7E;AAAA,UACF;AAAA,QACF;AAEA,eAAO,MAAM,IAAI,aAAa,OAAO,KAAK,CAAC;AAAA,MAC7C;AAAA,MACA,OAAO,SAAS,SAAS,MAAM;AAC7B,YAAI,kBAAkB,OAAO,GAAG;AAC9B,gBAAM,IAAI;AAAA,YACR,oDAAoD,QAAQ,SAAS,CAAC;AAAA,UACxE;AAAA,QACF;AAEA,eAAO,MAAM,OAAO,SAAS,OAAO;AAAA,MACtC;AAAA,IACF;AAEA,WAAO,MAAM,eAAe,IAAI,KAAK,MAAM,CAAC,mBAAmB;AAC7D,qBAAe,MAAM,kBAAkB,IAAI,KAAK,MAAM,CAAC,iBAAiB;AACtE,eAAO,CAAC,GAAG,cAAc,0BAA0B;AAAA,MACrD,CAAC;AAAA,IACH,CAAC;AAED,WAAO,MAAM,OAAO,IAAI,KAAK,MAAM,CAAC,WAAW;AAC7C,yBAAmB;AAAA,IACrB,CAAC;AAED,WAAO,MAAM,oBAAoB,IAAI,KAAK,MAAM,CAAC,cAAc;AAC7D,4BAAsB;AAAA,IACxB,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/{index.esm.js → index.legacy-esm.js}

@@ -1,4 +1,5 @@
-class ComputedPropertiesPlugin {
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts
+var ComputedPropertiesPlugin = class {
   constructor() {
     this.name = "ComputedProperties";
   }
@@ -6,8 +7,8 @@ class ComputedPropertiesPlugin {
     let schemaController;
     let expressionEvaluator;
     const getExpressionType = (binding) => {
-      const dataType = schemaController == null ? void 0 : schemaController.getType(binding);
-      if ((dataType == null ? void 0 : dataType.type) === "Expression") {
+      const dataType = schemaController?.getType(binding);
+      if (dataType?.type === "Expression") {
         return dataType;
       }
     };
@@ -17,25 +18,28 @@ class ComputedPropertiesPlugin {
         const expType = getExpressionType(binding);
         if (expType) {
           const { exp } = expType;
-          const result = exp && (expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp, options == null ? void 0 : options.context));
-          return result != null ? result : expType.default;
+          const result = exp && expressionEvaluator?.evaluate(exp, options?.context);
+          return result ?? expType.default;
         }
-        return next == null ? void 0 : next.get(binding, options);
+        return next?.get(binding, options);
       },
       set(transaction, options, next) {
-        var _a;
         for (const setOperation of transaction) {
           if (getExpressionType(setOperation[0])) {
-            throw new Error(`Invalid 'set' operation on computed property: ${setOperation[0].asString()}`);
+            throw new Error(
+              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`
+            );
           }
         }
-        return (_a = next == null ? void 0 : next.set(transaction, options)) != null ? _a : [];
+        return next?.set(transaction, options) ?? [];
       },
       delete(binding, options, next) {
         if (getExpressionType(binding)) {
-          throw new Error(`Invalid 'delete' operation on computed property: ${binding.asString()}`);
+          throw new Error(
+            `Invalid 'delete' operation on computed property: ${binding.asString()}`
+          );
         }
-        return next == null ? void 0 : next.delete(binding, options);
+        return next?.delete(binding, options);
       }
     };
     player.hooks.dataController.tap(this.name, (dataController) => {
@@ -50,7 +54,8 @@ class ComputedPropertiesPlugin {
       expressionEvaluator = evaluator;
     });
   }
-}
-
-export { ComputedPropertiesPlugin };
-//# sourceMappingURL=index.esm.js.map
+};
+export {
+  ComputedPropertiesPlugin
+};
+//# sourceMappingURL=index.mjs.map

package/dist/{index.cjs.js → index.mjs}

@@ -1,8 +1,5 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-class ComputedPropertiesPlugin {
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts
+var ComputedPropertiesPlugin = class {
   constructor() {
     this.name = "ComputedProperties";
   }
@@ -10,8 +7,8 @@ class ComputedPropertiesPlugin {
     let schemaController;
     let expressionEvaluator;
     const getExpressionType = (binding) => {
-      const dataType = schemaController == null ? void 0 : schemaController.getType(binding);
-      if ((dataType == null ? void 0 : dataType.type) === "Expression") {
+      const dataType = schemaController?.getType(binding);
+      if (dataType?.type === "Expression") {
         return dataType;
       }
     };
@@ -21,25 +18,28 @@ class ComputedPropertiesPlugin {
         const expType = getExpressionType(binding);
         if (expType) {
           const { exp } = expType;
-          const result = exp && (expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp, options == null ? void 0 : options.context));
-          return result != null ? result : expType.default;
+          const result = exp && expressionEvaluator?.evaluate(exp, options?.context);
+          return result ?? expType.default;
         }
-        return next == null ? void 0 : next.get(binding, options);
+        return next?.get(binding, options);
       },
       set(transaction, options, next) {
-        var _a;
         for (const setOperation of transaction) {
           if (getExpressionType(setOperation[0])) {
-            throw new Error(`Invalid 'set' operation on computed property: ${setOperation[0].asString()}`);
+            throw new Error(
+              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`
+            );
           }
         }
-        return (_a = next == null ? void 0 : next.set(transaction, options)) != null ? _a : [];
+        return next?.set(transaction, options) ?? [];
       },
       delete(binding, options, next) {
         if (getExpressionType(binding)) {
-          throw new Error(`Invalid 'delete' operation on computed property: ${binding.asString()}`);
+          throw new Error(
+            `Invalid 'delete' operation on computed property: ${binding.asString()}`
+          );
         }
-        return next == null ? void 0 : next.delete(binding, options);
+        return next?.delete(binding, options);
       }
     };
     player.hooks.dataController.tap(this.name, (dataController) => {
@@ -54,7 +54,8 @@ class ComputedPropertiesPlugin {
       expressionEvaluator = evaluator;
     });
   }
-}
-
-exports.ComputedPropertiesPlugin = ComputedPropertiesPlugin;
-//# sourceMappingURL=index.cjs.js.map
+};
+export {
+  ComputedPropertiesPlugin
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/src/index.ts"],"sourcesContent":["import type {\n  Player,\n  PlayerPlugin,\n  ExpressionEvaluator,\n  Schema,\n  Expression,\n  DataModelMiddleware,\n  Updates,\n  SchemaController,\n  BindingInstance,\n} from \"@player-ui/player\";\n\nexport interface ExpressionDataType extends Schema.DataType<\"Expression\"> {\n  /** The expression to evaluate to compute the value of this node */\n  exp?: Expression;\n}\n\n/**\n * A player plugin to manage beacon events.\n * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.\n */\nexport class ComputedPropertiesPlugin implements PlayerPlugin {\n  name = \"ComputedProperties\";\n\n  apply(player: Player) {\n    // Inject a middleware into the data-model to intercept any calls to an expression type in the schema\n    // Calls to `set` throw an error. Calls to `get` compute the value and return if or default\n\n    let schemaController: SchemaController | undefined;\n    let expressionEvaluator: ExpressionEvaluator | undefined;\n\n    /** Look up the data-type of the binding, and check for an Expression type */\n    const getExpressionType = (\n      binding: BindingInstance,\n    ): ExpressionDataType | undefined => {\n      // Check to see if the data-type of the binding is an `Expression`\n      const dataType = schemaController?.getType(binding);\n\n      if (dataType?.type === \"Expression\") {\n        return dataType as ExpressionDataType;\n      }\n    };\n\n    const computedPropertyMiddleware: DataModelMiddleware = {\n      name: this.name,\n      get(binding, options, next) {\n        const expType = getExpressionType(binding);\n\n        if (expType) {\n          const { exp } = expType;\n          const result =\n            exp && expressionEvaluator?.evaluate(exp, options?.context);\n\n          return result ?? expType.default;\n        }\n\n        return next?.get(binding, options);\n      },\n      set(transaction, options, next): Updates {\n        for (const setOperation of transaction) {\n          if (getExpressionType(setOperation[0])) {\n            throw new Error(\n              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`,\n            );\n          }\n        }\n\n        return next?.set(transaction, options) ?? [];\n      },\n      delete(binding, options, next) {\n        if (getExpressionType(binding)) {\n          throw new Error(\n            `Invalid 'delete' operation on computed property: ${binding.asString()}`,\n          );\n        }\n\n        return next?.delete(binding, options);\n      },\n    };\n\n    player.hooks.dataController.tap(this.name, (dataController) => {\n      dataController.hooks.resolveDataStages.tap(this.name, (dataPipeline) => {\n        return [...dataPipeline, computedPropertyMiddleware];\n      });\n    });\n\n    player.hooks.schema.tap(this.name, (schema) => {\n      schemaController = schema;\n    });\n\n    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {\n      expressionEvaluator = evaluator;\n    });\n  }\n}\n"],"mappings":";AAqBO,IAAM,2BAAN,MAAuD;AAAA,EAAvD;AACL,gBAAO;AAAA;AAAA,EAEP,MAAM,QAAgB;AAIpB,QAAI;AACJ,QAAI;AAGJ,UAAM,oBAAoB,CACxB,YACmC;AAEnC,YAAM,WAAW,kBAAkB,QAAQ,OAAO;AAElD,UAAI,UAAU,SAAS,cAAc;AACnC,eAAO;AAAA,MACT;AAAA,IACF;AAEA,UAAM,6BAAkD;AAAA,MACtD,MAAM,KAAK;AAAA,MACX,IAAI,SAAS,SAAS,MAAM;AAC1B,cAAM,UAAU,kBAAkB,OAAO;AAEzC,YAAI,SAAS;AACX,gBAAM,EAAE,IAAI,IAAI;AAChB,gBAAM,SACJ,OAAO,qBAAqB,SAAS,KAAK,SAAS,OAAO;AAE5D,iBAAO,UAAU,QAAQ;AAAA,QAC3B;AAEA,eAAO,MAAM,IAAI,SAAS,OAAO;AAAA,MACnC;AAAA,MACA,IAAI,aAAa,SAAS,MAAe;AACvC,mBAAW,gBAAgB,aAAa;AACtC,cAAI,kBAAkB,aAAa,CAAC,CAAC,GAAG;AACtC,kBAAM,IAAI;AAAA,cACR,iDAAiD,aAAa,CAAC,EAAE,SAAS,CAAC;AAAA,YAC7E;AAAA,UACF;AAAA,QACF;AAEA,eAAO,MAAM,IAAI,aAAa,OAAO,KAAK,CAAC;AAAA,MAC7C;AAAA,MACA,OAAO,SAAS,SAAS,MAAM;AAC7B,YAAI,kBAAkB,OAAO,GAAG;AAC9B,gBAAM,IAAI;AAAA,YACR,oDAAoD,QAAQ,SAAS,CAAC;AAAA,UACxE;AAAA,QACF;AAEA,eAAO,MAAM,OAAO,SAAS,OAAO;AAAA,MACtC;AAAA,IACF;AAEA,WAAO,MAAM,eAAe,IAAI,KAAK,MAAM,CAAC,mBAAmB;AAC7D,qBAAe,MAAM,kBAAkB,IAAI,KAAK,MAAM,CAAC,iBAAiB;AACtE,eAAO,CAAC,GAAG,cAAc,0BAA0B;AAAA,MACrD,CAAC;AAAA,IACH,CAAC;AAED,WAAO,MAAM,OAAO,IAAI,KAAK,MAAM,CAAC,WAAW;AAC7C,yBAAmB;AAAA,IACrB,CAAC;AAED,WAAO,MAAM,oBAAoB,IAAI,KAAK,MAAM,CAAC,cAAc;AAC7D,4BAAsB;AAAA,IACxB,CAAC;AAAA,EACH;AACF;","names":[]}

package/package.json

@@ -1,67 +1,37 @@
 {
   "name": "@player-ui/computed-properties-plugin",
-  "version": "0.7.4-next.4",
-  "private": false,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
+  "version": "0.7.5--canary.434.14868",
+  "main": "dist/cjs/index.cjs",
   "peerDependencies": {
-    "@player-ui/player": "0.7.4-next.4"
+    "@player-ui/player": "0.7.5--canary.434.14868"
   },
-  "dependencies": {
-    "tapable-ts": "^0.2.3",
-    "@babel/runtime": "7.15.4"
+  "devDependencies": {
+    "@player-ui/asset-transform-plugin": "workspace:*",
+    "@player-ui/make-flow": "workspace:*",
+    "@player-ui/partial-match-registry": "workspace:*",
+    "@player-ui/common-expressions-plugin": "workspace:*",
+    "@player-ui/common-types-plugin": "workspace:*"
   },
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "typings": "dist/index.d.ts",
+  "module": "dist/index.legacy-esm.js",
+  "types": "types/index.d.ts",
+  "bundle": "dist/ComputedPropertiesPlugin.native.js",
   "sideEffects": false,
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/player-ui/player-ui"
-  },
-  "bugs": {
-    "url": "https://github.com/player-ui/player-ui/issues"
-  },
-  "homepage": "https://player-ui.github.io",
-  "contributors": [
-    {
-      "name": "Adam Dierkens",
-      "url": "https://github.com/adierkens"
-    },
-    {
-      "name": "Spencer Hamm",
-      "url": "https://github.com/spentacular"
-    },
-    {
-      "name": "Harris Borawski",
-      "url": "https://github.com/hborawski"
-    },
-    {
-      "name": "Jeremiah Zucker",
-      "url": "https://github.com/sugarmanz"
-    },
-    {
-      "name": "Ketan Reddy",
-      "url": "https://github.com/KetanReddy"
-    },
-    {
-      "name": "Brocollie08",
-      "url": "https://github.com/brocollie08"
-    },
-    {
-      "name": "Kelly Harrop",
-      "url": "https://github.com/kharrop"
-    },
-    {
-      "name": "Alejandro Fimbres",
-      "url": "https://github.com/lexfm"
-    },
-    {
-      "name": "Rafael Campos",
-      "url": "https://github.com/rafbcampos"
+  "exports": {
+    "./package.json": "./package.json",
+    "./dist/index.css": "./dist/index.css",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/cjs/index.cjs"
     }
+  },
+  "files": [
+    "dist",
+    "src",
+    "types"
   ],
-  "bundle": "./dist/computed-properties-plugin.prod.js"
+  "dependencies": {
+    "tapable-ts": "^0.2.3",
+    "tslib": "^2.6.2"
+  }
 }

package/src/__tests__/index.test.ts

@@ -0,0 +1,219 @@
+import { test, expect, vitest } from "vitest";
+import type { InProgressState, Flow } from "@player-ui/player";
+import { Player } from "@player-ui/player";
+import { makeFlow } from "@player-ui/make-flow";
+import { ComputedPropertiesPlugin } from "..";
+
+const flowWithComputedValues = makeFlow({
+  id: "view-1",
+  type: "view",
+  value: "{{foo.bar.computedValue}}",
+  otherValue: "{{foo.bar.otherValue}}",
+});
+
+flowWithComputedValues.schema = {
+  ROOT: {
+    foo: {
+      type: "FooType",
+    },
+  },
+  FooType: {
+    bar: {
+      type: "BarType",
+    },
+  },
+  BarType: {
+    computedValue: {
+      type: "Expression",
+      exp: "1 + 2 + 3",
+    },
+  },
+} as any;
+
+flowWithComputedValues.data = {
+  foo: {
+    bar: {
+      otherValue: "not 6",
+    },
+  },
+};
+
+test("computes property values for Expression schema types", () => {
+  const player = new Player({ plugins: [new ComputedPropertiesPlugin()] });
+  player.start(flowWithComputedValues);
+
+  const currentState = player.getState() as InProgressState;
+
+  expect(currentState.controllers.view.currentView?.lastUpdate).toStrictEqual({
+    id: "view-1",
+    type: "view",
+    value: 6,
+    otherValue: "not 6",
+  });
+});
+
+test("throws an error if writing to a computed value", () => {
+  const player = new Player({ plugins: [new ComputedPropertiesPlugin()] });
+  player.start(flowWithComputedValues);
+
+  const state = player.getState() as InProgressState;
+
+  expect(() =>
+    state.controllers.data.set([["foo.bar.computedValue", "val"]]),
+  ).toThrowError(
+    "Invalid 'set' operation on computed property: foo.bar.computedValue",
+  );
+});
+
+test("sets fall through", () => {
+  const player = new Player({ plugins: [new ComputedPropertiesPlugin()] });
+  player.start(flowWithComputedValues);
+
+  const state = player.getState() as InProgressState;
+
+  expect(state.controllers.data.get("foo.bar.otherValue")).toBe("not 6");
+  state.controllers.data.set([["foo.bar.otherValue", "updated"]]);
+  expect(state.controllers.data.get("foo.bar.otherValue")).toBe("updated");
+});
+
+const flowWithComputedApplicability = makeFlow({
+  id: "view-1",
+  type: "view",
+  label: {
+    asset: {
+      applicability: "{{foo.computedValue}}",
+      id: "label",
+      type: "text",
+      value: "view label",
+    },
+  },
+});
+
+flowWithComputedApplicability.schema = {
+  ROOT: {
+    foo: {
+      type: "FooType",
+    },
+  },
+  FooType: {
+    computedValue: {
+      type: "Expression",
+      exp: '{{foo.type}} === "valid"',
+    },
+  },
+};
+
+flowWithComputedApplicability.data = {
+  foo: { type: "not-valid" },
+};
+
+test("updates work across computations", async () => {
+  const player = new Player({ plugins: [new ComputedPropertiesPlugin()] });
+  player.start(flowWithComputedApplicability);
+
+  const getView = () => {
+    return (player.getState() as InProgressState).controllers.view.currentView
+      ?.lastUpdate as any;
+  };
+
+  // The label should start off as not there
+
+  expect(getView().label).toBe(undefined);
+
+  (player.getState() as InProgressState).controllers.data.set([
+    ["foo.type", "valid"],
+  ]);
+
+  await vitest.waitFor(() =>
+    expect(getView().label).toStrictEqual({
+      asset: {
+        id: "label",
+        type: "text",
+        value: "view label",
+      },
+    }),
+  );
+
+  (player.getState() as InProgressState).controllers.data.set([
+    ["foo", { type: "not-valid" }],
+  ]);
+
+  await vitest.waitFor(() => expect(getView().label).toBe(undefined));
+});
+
+test("expressions update dependent expressions", async () => {
+  const flowWithDependentComputedValues: Flow = makeFlow({
+    views: [
+      {
+        id: "view-1",
+        type: "view",
+        computed: {
+          asset: {
+            id: "computed",
+            type: "text",
+            applicability: "{{foo.bar.computedValue}}",
+          },
+        },
+        dependent: {
+          asset: {
+            id: "dependent",
+            type: "text",
+            applicability: "{{foo.bar.dependentValue}}",
+          },
+        },
+      },
+    ],
+    data: {
+      foo: {
+        bar: {
+          sourceValue: false,
+        },
+      },
+    },
+    schema: {
+      ROOT: {
+        foo: {
+          type: "FooType",
+        },
+      },
+      FooType: {
+        bar: {
+          type: "BarType",
+        },
+      },
+      BarType: {
+        sourceValue: {
+          type: "boolean",
+        },
+        computedValue: {
+          type: "Expression",
+          exp: "{{foo.bar.sourceValue}} == true",
+        },
+        dependentValue: {
+          type: "Expression",
+          exp: "{{foo.bar.computedValue}} == false",
+        },
+      },
+    },
+  });
+  const player = new Player({ plugins: [new ComputedPropertiesPlugin()] });
+  player.start(flowWithDependentComputedValues);
+
+  const getView = () => {
+    return (player.getState() as InProgressState).controllers.view.currentView
+      ?.lastUpdate as any;
+  };
+
+  // The label should start off as not there
+
+  expect(getView().computed).toBeUndefined();
+  expect(getView().dependent).toBeDefined();
+
+  (player.getState() as InProgressState).controllers.data.set([
+    ["foo.bar.sourceValue", true],
+  ]);
+  await vitest.waitFor(() => {
+    expect(getView().computed).toBeDefined();
+    expect(getView().dependent).toBeUndefined();
+  });
+});

package/src/__tests__/validation.test.ts

@@ -0,0 +1,217 @@
+import { test, expect, describe } from "vitest";
+import { CommonExpressionsPlugin } from "@player-ui/common-expressions-plugin";
+import { CommonTypesPlugin } from "@player-ui/common-types-plugin";
+import { Registry } from "@player-ui/partial-match-registry";
+import { AssetTransformPlugin } from "@player-ui/asset-transform-plugin";
+import { makeFlow } from "@player-ui/make-flow";
+import { Player } from "@player-ui/player";
+import type {
+  Asset,
+  BindingInstance,
+  TransformFunction,
+  ValidationResponse,
+} from "@player-ui/player";
+import { ComputedPropertiesPlugin } from "..";
+
+// This is a flow that uses computed properties for evaluating cross field validation
+const flowWithComputedValidation = makeFlow({
+  id: "view-1",
+  type: "view",
+  template: [
+    {
+      data: "items",
+      output: "bindings",
+      value: "items._index_.isRelevant",
+    },
+  ],
+  validation: [
+    {
+      type: "expression",
+      ref: "items.0.isRelevant",
+      message: "Please select at least one item.",
+      exp: "{{expressions.SelectionValidation}}",
+    },
+  ],
+});
+
+flowWithComputedValidation.schema = {
+  ROOT: {
+    items: {
+      type: "ItemType",
+      isArray: true,
+    },
+    expressions: {
+      type: "ExpressionsType",
+    },
+  },
+  itemType: {
+    name: {
+      type: "TextType",
+    },
+    isRelevant: {
+      type: "BooleanType",
+    },
+  },
+  ExpressionsType: {
+    SelectionValidation: {
+      type: "Expression",
+      exp: 'findProperty({{items}}, "isRelevant", true, "isRelevant", false)',
+    },
+  },
+};
+
+flowWithComputedValidation.data = {
+  items: [
+    {
+      name: "One",
+      isRelevant: false,
+    },
+    {
+      name: "Two",
+      isRelevant: false,
+    },
+  ],
+};
+
+interface ValidationView extends Asset<"view"> {
+  /**
+   *
+   */
+  bindings: string[];
+}
+
+/**
+ *
+ */
+const validationTrackerTransform: TransformFunction<
+  ValidationView,
+  ValidationView & {
+    /**
+     *
+     */
+    validation?: ValidationResponse;
+  }
+> = (asset, options) => {
+  const { bindings } = asset;
+  let validation: ValidationResponse | undefined;
+
+  // Setup tracking on each binding
+  bindings.forEach((binding) => {
+    validation =
+      options.validation?.get(binding, { track: true }) ?? validation;
+  });
+
+  return {
+    ...asset,
+    validation,
+  };
+};
+
+describe("cross field validation can use computed properties", () => {
+  /**
+   *
+   */
+  const baseValidationTest = (dataUpdate: Record<string, any>) => async () => {
+    const player = new Player({
+      plugins: [
+        // necessary for data middleware to reference {{expressions}}
+        new ComputedPropertiesPlugin(),
+
+        // necessary for expression type validation
+        new CommonTypesPlugin(),
+        // necessary for findProperty
+        new CommonExpressionsPlugin(),
+
+        // necessary to track validations
+        new AssetTransformPlugin(
+          new Registry([[{ type: "view" }, validationTrackerTransform]]),
+        ),
+      ],
+    });
+
+    const result = player.start(flowWithComputedValidation);
+
+    /**
+     *
+     */
+    const getControllers = () => {
+      const state = player.getState();
+      if (state.status === "in-progress") {
+        return state.controllers;
+      }
+    };
+
+    /**
+     *
+     */
+    const getCurrentView = () => {
+      const controllers = getControllers();
+      return controllers ? controllers.view.currentView : undefined;
+    };
+
+    /**
+     *
+     */
+    const withValidations = (
+      assertions: (validations: {
+        /**
+         *
+         */
+        canTransition: boolean;
+        /**
+         *
+         */
+        validations?: Map<BindingInstance, ValidationResponse>;
+      }) => void,
+    ) => assertions(getControllers()!.validation.validateView()!);
+
+    expect(getCurrentView()?.initialView.id).toBe("view-1");
+
+    withValidations(({ canTransition, validations }) => {
+      expect(canTransition).toBe(false);
+      expect(validations?.size).toBe(1);
+    });
+
+    getControllers()?.flow.transition("Next");
+
+    // Transition fails do to blocking validation
+    expect(getCurrentView()?.initialView.id).toBe("view-1");
+
+    getControllers()?.data.set(dataUpdate);
+
+    withValidations(({ canTransition, validations }) => {
+      expect(canTransition).toBe(true);
+      expect(validations).toBeUndefined();
+    });
+
+    getControllers()?.flow.transition("Next");
+
+    const { endState } = await result;
+    expect(endState).toStrictEqual({
+      outcome: "done",
+      state_type: "END",
+    });
+  };
+
+  test(
+    "updating ref data should remove validation",
+    baseValidationTest({
+      "items.0.isRelevant": true,
+    }),
+  );
+
+  test(
+    "updating non-ref data should remove validation",
+    baseValidationTest({
+      "items.1.isRelevant": true,
+    }),
+  );
+
+  test(
+    "updating both should remove validation",
+    baseValidationTest({
+      "items.0.isRelevant": true,
+      "items.1.isRelevant": true,
+    }),
+  );
+});

package/src/index.ts

@@ -8,9 +8,9 @@ import type {
   Updates,
   SchemaController,
   BindingInstance,
-} from '@player-ui/player';
+} from "@player-ui/player";
 
-export interface ExpressionDataType extends Schema.DataType<'Expression'> {
+export interface ExpressionDataType extends Schema.DataType<"Expression"> {
   /** The expression to evaluate to compute the value of this node */
   exp?: Expression;
 }
@@ -20,7 +20,7 @@ export interface ExpressionDataType extends Schema.DataType<'Expression'> {
  * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.
  */
 export class ComputedPropertiesPlugin implements PlayerPlugin {
-  name = 'ComputedProperties';
+  name = "ComputedProperties";
 
   apply(player: Player) {
     // Inject a middleware into the data-model to intercept any calls to an expression type in the schema
@@ -31,12 +31,12 @@ export class ComputedPropertiesPlugin implements PlayerPlugin {
 
     /** Look up the data-type of the binding, and check for an Expression type */
     const getExpressionType = (
-      binding: BindingInstance
+      binding: BindingInstance,
     ): ExpressionDataType | undefined => {
       // Check to see if the data-type of the binding is an `Expression`
       const dataType = schemaController?.getType(binding);
 
-      if (dataType?.type === 'Expression') {
+      if (dataType?.type === "Expression") {
         return dataType as ExpressionDataType;
       }
     };
@@ -60,7 +60,7 @@ export class ComputedPropertiesPlugin implements PlayerPlugin {
         for (const setOperation of transaction) {
           if (getExpressionType(setOperation[0])) {
             throw new Error(
-              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`
+              `Invalid 'set' operation on computed property: ${setOperation[0].asString()}`,
             );
           }
         }
@@ -70,7 +70,7 @@ export class ComputedPropertiesPlugin implements PlayerPlugin {
       delete(binding, options, next) {
         if (getExpressionType(binding)) {
           throw new Error(
-            `Invalid 'delete' operation on computed property: ${binding.asString()}`
+            `Invalid 'delete' operation on computed property: ${binding.asString()}`,
           );
         }
 

package/{dist → types}/index.d.ts

@@ -1,6 +1,5 @@
-import { Schema, Expression, PlayerPlugin, Player } from '@player-ui/player';
-
-interface ExpressionDataType extends Schema.DataType<'Expression'> {
+import type { Player, PlayerPlugin, Schema, Expression } from "@player-ui/player";
+export interface ExpressionDataType extends Schema.DataType<"Expression"> {
     /** The expression to evaluate to compute the value of this node */
     exp?: Expression;
 }
@@ -8,9 +7,8 @@ interface ExpressionDataType extends Schema.DataType<'Expression'> {
  * A player plugin to manage beacon events.
  * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.
  */
-declare class ComputedPropertiesPlugin implements PlayerPlugin {
+export declare class ComputedPropertiesPlugin implements PlayerPlugin {
     name: string;
     apply(player: Player): void;
 }
-
-export { ComputedPropertiesPlugin, ExpressionDataType };
+//# sourceMappingURL=index.d.ts.map

package/dist/computed-properties-plugin.dev.js

@@ -1,170 +0,0 @@
-(function webpackUniversalModuleDefinition(root, factory) {
-	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory();
-	else if(typeof define === 'function' && define.amd)
-		define([], factory);
-	else if(typeof exports === 'object')
-		exports["ComputedPropertiesPlugin"] = factory();
-	else
-		root["ComputedPropertiesPlugin"] = factory();
-})(this, function() {
-return /******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/dist/index.esm.js");
-/******/ })
-/************************************************************************/
-/******/ ({
-
-/***/ "./bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/dist/index.esm.js":
-/*!***************************************************************************************!*\
-  !*** ./bazel-out/k8-fastbuild/bin/plugins/computed-properties/core/dist/index.esm.js ***!
-  \***************************************************************************************/
-/*! exports provided: ComputedPropertiesPlugin */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ComputedPropertiesPlugin", function() { return ComputedPropertiesPlugin; });
-class ComputedPropertiesPlugin {
-  constructor() {
-    this.name = "ComputedProperties";
-  }
-  apply(player) {
-    let schemaController;
-    let expressionEvaluator;
-    const getExpressionType = (binding) => {
-      const dataType = schemaController == null ? void 0 : schemaController.getType(binding);
-      if ((dataType == null ? void 0 : dataType.type) === "Expression") {
-        return dataType;
-      }
-    };
-    const computedPropertyMiddleware = {
-      name: this.name,
-      get(binding, options, next) {
-        const expType = getExpressionType(binding);
-        if (expType) {
-          const { exp } = expType;
-          const result = exp && (expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp, options == null ? void 0 : options.context));
-          return result != null ? result : expType.default;
-        }
-        return next == null ? void 0 : next.get(binding, options);
-      },
-      set(transaction, options, next) {
-        var _a;
-        for (const setOperation of transaction) {
-          if (getExpressionType(setOperation[0])) {
-            throw new Error(`Invalid 'set' operation on computed property: ${setOperation[0].asString()}`);
-          }
-        }
-        return (_a = next == null ? void 0 : next.set(transaction, options)) != null ? _a : [];
-      },
-      delete(binding, options, next) {
-        if (getExpressionType(binding)) {
-          throw new Error(`Invalid 'delete' operation on computed property: ${binding.asString()}`);
-        }
-        return next == null ? void 0 : next.delete(binding, options);
-      }
-    };
-    player.hooks.dataController.tap(this.name, (dataController) => {
-      dataController.hooks.resolveDataStages.tap(this.name, (dataPipeline) => {
-        return [...dataPipeline, computedPropertyMiddleware];
-      });
-    });
-    player.hooks.schema.tap(this.name, (schema) => {
-      schemaController = schema;
-    });
-    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {
-      expressionEvaluator = evaluator;
-    });
-  }
-}
-
-
-//# sourceMappingURL=index.esm.js.map
-
-
-/***/ })
-
-/******/ });
-});

package/dist/computed-properties-plugin.prod.js

@@ -1 +0,0 @@
-!function(e,t){"object"===typeof exports&&"object"===typeof module?module.exports=t():"function"===typeof define&&define.amd?define([],t):"object"===typeof exports?exports.ComputedPropertiesPlugin=t():e.ComputedPropertiesPlugin=t()}(this,(function(){return function(e){var t={};function o(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,o),r.l=!0,r.exports}return o.m=e,o.c=t,o.d=function(e,t,n){o.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},o.r=function(e){"undefined"!==typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.t=function(e,t){if(1&t&&(e=o(e)),8&t)return e;if(4&t&&"object"===typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var r in e)o.d(n,r,function(t){return e[t]}.bind(null,r));return n},o.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(t,"a",t),t},o.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},o.p="",o(o.s=0)}([function(e,t,o){"use strict";o.r(t),o.d(t,"ComputedPropertiesPlugin",(function(){return n}));class n{constructor(){this.name="ComputedProperties"}apply(e){let t,o;const n=e=>{const o=null==t?void 0:t.getType(e);if("Expression"===(null==o?void 0:o.type))return o},r={name:this.name,get(e,t,r){const u=n(e);if(u){const{exp:e}=u,n=e&&(null==o?void 0:o.evaluate(e,null==t?void 0:t.context));return null!=n?n:u.default}return null==r?void 0:r.get(e,t)},set(e,t,o){var r;for(const u of e)if(n(u[0]))throw new Error(`Invalid 'set' operation on computed property: ${u[0].asString()}`);return null!=(r=null==o?void 0:o.set(e,t))?r:[]},delete(e,t,o){if(n(e))throw new Error(`Invalid 'delete' operation on computed property: ${e.asString()}`);return null==o?void 0:o.delete(e,t)}};e.hooks.dataController.tap(this.name,(e=>{e.hooks.resolveDataStages.tap(this.name,(e=>[...e,r]))})),e.hooks.schema.tap(this.name,(e=>{t=e})),e.hooks.expressionEvaluator.tap(this.name,(e=>{o=e}))}}}])}));