skandha 0.9.0 → 0.9.1

package/README.md

@@ -2,10 +2,7 @@
 
 ## Rationale
 
-The goal of SkandhaJS is to provide data containers that have reusable behaviors, such as
-selection, highlighting, filtering, drag-and-drop, etc. The only requirement for using these containers is
-that every item in the container has a unique id. SkandhaJS allows you to combine behaviors and make them interact properly. For example, when selecting an item you may want the item also to
-be highlighted. As we will see, these interactions are achieved by implementing callback functions.
+The goal of SkandhaJS is to provide data containers that have reusable behaviors, such as selection, highlighting, filtering, drag-and-drop, etc. The only requirement for using these containers is that every item in the container has a unique id. SkandhaJS allows you to combine behaviors and make them interact properly. For example, when selecting an item you may want the item also to be highlighted. As we will see, these interactions are achieved by implementing callback functions.
 
 ## Links
 
@@ -15,94 +12,103 @@ be highlighted. As we will see, these interactions are achieved by implementing
 - The [aspiration](http://github.com/mnieber/aspiration) library handles aspect oriented programming (AOP)
 - The [example code](http://github.com/mnieber/skandha-sample-app) shown in this README.
 
-## Snippet
+## Glossary (conceptual)
+
+- callbacks object: a collection of callback functions that is used by an operation.
+- container: a class that contains multiple facets.
+- facet: a class that implements a reusable behaviour, such as selection.
+- operation: a member function of a facet that changes the data of that facet.
+
+## Glossary (technical)
+
+- aspiration: a library that implements a form of Aspect Oriented Programming using callback functions.
+- registerCtr: the function that tells SkandhaJS which containers and facets exist.
+- setCallbacks: the function that installs the callbacks objects that are used by a facet.
+
+## Example: a simplified Selection facet
+
+In Skandha, behaviours (such as selection, or filtering) are implemented in so-called facets that live in containers. For example, a todo container may have facets for selecting, highlighting and filtering todos. Because facets are reusable, they can also be used in other containers. And because facets are abstractions, you can use them to create UI components that handle selection in any container. In this example, we will show a simplified Selection facet class.
 
 ```
 // file: Selection.ts
 import { input, output, operation } from 'skandha';
-import { host, stub } from 'aspiration';
 
 export type SelectionParamsT = { itemId?: string; isShift?: boolean; isCtrl?: boolean; };
 
 export class Selection<ValueT = any> {
   static className = () => 'Selection';
 
-  @input selectableIds: Array<string> = stub();
+  @input selectableIds: Array<string> = [];
   @output ids: Array<string> = [];
   @output anchorId?: string;
-  @output items: Array<ValueT> = stub();
+  @output items: Array<ValueT> = [];
 
-  @operation @host(['selectionParams'], selectItemDefaultCbs) selectItem(
-    selectionParams: SelectionParamsT
-  ) {
-    return (cbs: Selection_selectItem) => {
-      cbs.select();
-    };
+  @operation selectItem(selectionParams: SelectionParamsT) {
+    // This function calls a callback function to do the actual work.
+    // Details about how this works are omitted for now.
   }
 }
 ```
 
-## Fact: the Selection facet has input, data and output members
+## Fact: facets have @input, @data and @output members
 
-In the snippet above we see a so-called Facet class. A facet class implements a reusable behaviour. The `Selection` facet stores a list of selectable ids and has a `selectItem` function that allows you to select from those ids. The result of the selection is stored in the `ids`, `anchorId` and `items` fields. Note that `selectItem` is an empty function. The exact method for doing the selection is determined by a callback function, as we shall see later.
+In `Selection.ts` we see the Selection facet class. It has a `selectableIds` field that stores the list of ids from which we can select. It is marked with the `@input` decorator because this field stores an input. The `ids`, `anchorId` and `items` fields are marked as `@output` fields. They are used to store the result of calling `selectItem()`.
 
-## Fact: the Selection facet has a static className function
+## Fact: operations are decorated with `@operation`.
 
-Various facets are usually combined in a single container. To allow you to look up a facet by it's name, each facet class implements the static `className` function.
+Conceptually, an operation is a member function that is used to manipulate the facet. The `Selection` facet has a `selectItems` operation that allows you to select from the selectable ids. It stores its results in the `ids`, `anchorId` and `items` fields.
+As the comment mentions, `selectItem()` calls a callback function to do the actual work. The reason is that the correct way to make a selection (e.g. what should happen if shift is pressed?) depends on the use-case. Therefore, we want to leave it up to the client to decide this.
 
-## Fact: the `selectItem` function uses a callback function
+## Fact: operations are logged
 
-We shall see later how callbacks are installed in a facet. For now, it's sufficient to understand that `selectItem` (the host function) executes the `cbs.selectItem()` callback function. This callback function will have access to all parameters of the host function (in this case: `selectionParams`).
+As a side effect of calling an operation, the entire container is logged to the console; this includes the Selection facet, and any other facets that the container may have. The log message contains all @input, @data and @output fields of all facets in the container.
 
-## Snippet
+## Example: a container with Selection, Highlight and Filtering
 
-```
-// file: Selection.ts
-export class Selection_selectItem extends Cbs {
-  selectionParams: SelectionParamsT = stub();
-  select() {}
-}
-```
+Now that we have some idea of what a facet is, we will discuss containers.
+In this example we will take a look at a todos container. It uses the `Selection` facet that we saw earlier.
 
 ```
 // file: createContainer.ts
-import { registerCtr } from 'skandha';
+import { Selection_selectItem } from 'SelectionCbs';
 
 const createContainer() {
   const ctr = {
-    selection: new Selection()
+    selection: new Selection(),
+    highlight: new Highlight(),
+    filtering: new Filtering()
   };
 
   setCallbacks(ctr.selection, {
     selectItem: {
       select(this: Selection_selectItem): {
         handleSelectItem(ctr.selection, this.selectionParams);
+        highlightFollowsSelection(ctr, this.selectionParams);
       },
     }
   });
 
-  // If you omit `members` then all fields of `ctr` are included.
-  registerCtr(ctr, { name: 'TodosCtr', members: ['selection'] });
+  setCallbacks(ctr.filtering, {
+    apply: {
+      exit() {
+        highlightIsCorrectedOnFilterChange(ctr);
+      },
+    },
+  });
+
+  registerCtr({ ctr: ctr, options: { name: 'Todos'} });
   return ctr;
 }
 ```
 
-## Fact: a Cbs class defines a set of callbacks
-
-In the above snippet we see that the `Selection_selectItem` class defines the callbacks that can be installed for the `selectItem` function of the `Selection` facet. This class also defines the parameters that are received by the host function and made available to each callback.
-
-## Fact: the setCallbacks function installs the callbacks for the Selection facet
-
-In the same snippet we see that `setCallbacks` is called to install the `select` callback function. This callback function forwards to a helper function called `handleSelectItem`. Note that the `Selection_selectItem` instance is available through the `this` constant.
-
-## Fact: the registerCtr function registers the container with SkandhaJS
-
-The purpose of calling registerCtr on the container is twofold:
-
-- it makes it possible to look up a facet by its name or class, e.g. `getf(ctr, Selection)` returns `ctr.selection`.
-- it tells SkandhaJS what facets should be included in log reports. When the client calls any facet function that is decorated with @operation then SkandhaJS will log the entire container before and after the operation was executed. Logging can be enabled using the `setOptions` function.
-
-## Snippet: the handleSelectItem functon
+```
+// file: highlightFollowsSelection.ts
+const highlightFollowsSelection = (ctr: any, selectionParams: SelectionParamsT) => {
+  if (!selectionParams.isShift && !selectionParams.isCtrl) {
+    ctr.highlight.highlightItem(selectionParams.itemId);
+  }
+}
+```
 
 ```
 // file: handleSelectItem.ts
@@ -133,145 +139,125 @@ export function handleSelectItem(
 }
 ```
 
-## Fact: the handleSelectItem does the actual work of selecting items
+## Note: the todos container has selection, highlight and filtering
 
-For completeness, we show how `handleSelectItem` is implemented. Note that this function stores the results directly in the selection facet instance.
+In `createContainer.ts` we see how `createContainer()` creates a `ctr` object that has three facets: selection, highlight and filtering. After creating the container, the `installCallbacks` function is called to determine how the facet operations are implemented. Finally, `registerCtr()` is called to allow SkandhaJS to introspect the container. This is necessary for two reasons. First, it makes it possible to look up a facet by its name or class, e.g. `getf(ctr, Selection)` returns `ctr.selection`. Second, it informs SkandhaJS how to log all facets of the container
 
-## Snippet: the Highlight facet
-
-```
-// file: Highlight.ts
-export class Highlight_highlightItem extends Cbs {
-  id: string = stub();
-  scrollItemIntoView() {}
-}
+## Fact: callbacks are installed with `setCallbacks`
 
-export class Highlight<ValueT = any> {
-  @data id?: string;
-  @data item?: ValueT;
+We call `setCallbacks` to install a callbacks object for each operation of the `Selection` facet. The callbacks object contains all callbacks for an operation. In our case we only have one operation (`selectItem()`) that has only one callback (`select()`). This callback function calls `handleSelectItem` to take care of doing the selection. This is a typical pattern: you want the call to `setCallbacks` to be as short and readable as possible, so that it's easy to understand what happens in each operation of each facet.
 
-  @operation @host(["id"]) highlightItem(id: string) {
-    return (cbs: Highlight_highlightItem) => {
-      this.id = id;
-      if (cbs.scrollItemIntoView) {
-        cbs.scrollItemIntoView();
-      }
-    };
-  }
-}
-```
+## Fact: callbacks can take care of side effects
 
-## Fact: the `Highlight` facet implements the highlight behaviour
+An important advantage of using callbacks is that they can also take care of side effects. In this case, it calls `highlightFollowsSelection()` to ensure that selected items are also highlighted. Note that the callback function is able to connect selection and highlight because it has access to the entire container.
 
-The `Highlight` snippet has a similar structure as the `Selection` facet. It has a callback function for scrolling the highlighted item into view. Note that the `highlightItem` function does not set the `item` field, because the facet only deals with ids. We shall later see how the `item` field is set by looking up the item in an external collection.
+## Fact: the callback function can access the callbacks object through `this`.
 
-## Snippet: a container with Selection and Highlight
+When the clients calls `ctr.selection.selectItem()` and `select` is called back, then all arguments of the operation are available through `this`. In our case, we see that the `select` callback function is accessing `this.selectionParams`.
 
-```
-// file: createContainer.ts
-const createContainer() {
-  const ctr = {
-    selection: new Selection(),
-    highlight: new Highlight()
-  };
+## Fact: the `exit` callback function is called at the end of an operation
 
-  setCallbacks(ctr.selection, {
-    selectItem: {
-      select(this: Selection_selectItem): {
-        handleSelectItem(ctr.selection, this.selectionParams);
+In `createContainer.ts` we also have a `Filtering` facet that has an `apply(f)` operation (where `f` is the filter function). In this operation, we install the `exit()` callback that corrects the highlight when the filter function changes (because the new filter may hide the highlighted item). The `exit()` callback is called automatically at the end of each operation. Similarly, the `enter()` callback is called at the beginning.
 
-        if (!this.selectionParams.isShift && !this.selectionParams.isCtrl) {
-          ctr.highlight.highlightItem(this.selectionParams.itemId);
-        }
+## Example: a complete Selection facet
 
-        // The above 3 lines could be extracted in a reusable helper function, e.g.
-        // highlightFollowsSelection(ctr, this.selectionParams);
-      },
-    }
-  });
+It's time now to return to the Selection facet and show how callbacks really work.
 
-  return ctr;
 ```
+// file: Selection.ts
+import { input, output, operation } from 'skandha';
+import { host, stub } from 'aspiration';
+import { Selection_selectItem, SelectionParamsT } from 'SelectionCbs';
 
-## Fact: callbacks allow you to create co-ordinated behaviours
-
-Above we see for the first time how SkandhaJS helps you to create co-ordinated behaviours. When the client calls `ctr.selection.selectItem` and the `select` callback is executed, then the callback ensures that the selected item is also highlighted. As the comment in the snippet suggests, we can make the body of the `select` callback more readable by extracting some of the code in a `highlightFollowsSelection` helper function.
+export class Selection<ValueT = any> {
+  static className = () => 'Selection';
 
-## Snippet: a container with Selection, Highlight and Filtering
+  @input selectableIds: Array<string> = stub();
+  @output ids: Array<string> = [];
+  @output anchorId?: string;
+  @output items: Array<ValueT> = stub();
 
+  @operation @host(['selectionParams']) selectItem(
+    selectionParams: SelectionParamsT
+  ) {
+    return (cbs: Selection_selectItem) => {
+      cbs.select();
+    };
+  }
+}
 ```
-// file: createContainer.ts
-const createContainer() {
-  const ctr = {
-    selection: new Selection(),
-    highlight: new Highlight(),
-    filtering: new Filtering()
-  };
 
-  setCallbacks(ctr.selection, {
-    selectItem: {
-      select(this: Selection_selectItem): {
-        handleSelectItem(ctr.selection, this.selectionParams);
-        highlightFollowsSelection(ctr, this.selectionParams);
-      },
-    }
-  });
+```
+// file: SelectionCbs.ts
+import { stub } from 'aspiration';
 
-  setCallbacks(filtering, {
-    apply: {
-      exit() {
-        highlightIsCorrectedOnFilterChange(ctr);
-      },
-    },
-  });
+export type SelectionParamsT = { itemId?: string; isShift?: boolean; isCtrl?: boolean; };
 
-  return ctr;
+export class Selection_selectItem extends Cbs {
+  selectionParams: SelectionParamsT = stub();
+  select() {}
 }
 ```
 
-## Fact: the `exit` callback function is called at the end of the host function
+## Fact: the `@host` decorator is used to enable callbacks in an operation.
+
+The `@host` decorator comes from the `Aspiration` library. When you call a function `f` that is decorated with `@host` then the following happens:
+
+- Aspiration looks up the callbacks object for the operation (that was installed with `setCallbacks`)
+- it copies the operation arguments to the callbacks object (so that callback functions can access these arguments)
+- if calls `f(arguments)(callbacksObject)`.
+
+Remember that `f` is the original function. We see from the example that `f` returns a closure. This closure receives the callbacks object, but (because it's a closure) it also has access to the arguments of f. This approach allows the client code to call `f` in the usual way; it can be agnostic of the fact that callbacks are used to help implement `f`.
+
+## Fact: callback functions have access to all operation arguments
+
+As we mentioned earlier, each callback function of the callbacks object has access to all arguments of the operation. For this to work, it's required that you pass the list of argument names to the `@host` decorator (unfortunately, typescript does not have introspection capabilities that allow to automate this). These names need to match the corresponding fields of the callbacks object class (`Selection_selectItem`).
+
+## Fact: facets have a static `className()` function
 
-In the snippet we add a filtering facet that has an `apply` host function. In this host function, we can install an `exit` callback that corrects the highlight when the filter changes (because the filter may hide the highlighted item). The `exit` callback is called at the end of the host function. Similarly, the `enter` callback is called at the beginning.
+To allow SkandhaJS to introspect the container, you need to add the `className()` function to each facet class, so that Skandha knows the name of the facet.
 
-## Snippet: mapping data onto each facet
+## Example: a Connector maps data onto each facet
+
+We've seen how facets are implemented, and how they can be added to a container in a way that allows us to create interactions between them. Since our container contains selection and filtering, we should only allow selection of todos that have not been filtered out. In other words, the list of selectable ids should be derived from the list of filtered todos. Moreover, we need to load the todos and set them as the inputs of the filtering facet. In this example, we show two containers (data and todos) and how to map data between them.
 
 ```
 // file: createContainer.ts
 import * from 'ramda' as R;
 
 const connectContainer(ctr: any) {
-  const inputs = { todos: loadTodos() };
-  const outputs = { filteredTodoById: {} };
-
-  const con = createConnector({
-    selection: () => ctr.selection,
-    highlight: () => ctr.highlight,
-    filtering: () => ctr.filtering`,
-    inputs: () => inputs,
-    outputs: () => outputs,
-  });
+  const data = {
+    inputs: { todos: loadTodos() },
+    outputs: { filteredTodoById: {} },
+  };
+
+  const todos = {
+    selection: new Selection(),
+    highlight: new Highlight(),
+    filtering: new Filtering(),
+  }
 
-  const lookUpTodo = (id: string) => outputs.filteredTodoById[id];
+  const con = createConnector({ data: data, todos: todos });
+  const lookUpTodo = (id: string) => outputsCtr.filteredTodoById[id];
 
-  con.filtering.inputItems = con.inputs.todos;
-  con.outputs.filteredTodoById = con.filtering.filteredItems.tf(R.indexBy('id));
-  con.selection.selectableIds = con.outputs.filteredTodoById.tf(R.keys);
-  con.selection.item = con.selection.ids.tf(lookUpTodos);
-  con.highlight.item = con.highlight.id.tf(lookUpTodo);
+  con['todos.filtering'].inputItems = con['inputs'].todos;
+  con['outputs'].filteredTodoById = con['todos.filtering'].filteredItems.tf(R.indexBy('id));
+  con['todos.selection'].selectableIds = con['outputs'].filteredTodoById.tf(R.keys);
+  con['todos.selection'].item = con['todos.selection'].ids.tf(lookUpTodos);
+  con['todos.highlight'].item = con['todos.highlight'].id.tf(lookUpTodo);
 
   con.connect();
 ```
 
 ## Fact: the Connector class maps data between objects
 
-The Connector instance allows you to map data from one object onto another object. In our example, the `inputs.todos` field is mapped onto the `filtering.inputItems` field. What the `Connector` class does is turn `filtering.inputItems` into a `get` property that returns `filtering.inputItems`.
-The snippet contains three steps. In the first step we declare the objects, such as `selection`, `filtering`, etc. For each object, we specify the getter function that returns the object. In the second step, we declare relations between the different fields of these objects. In this step, we can also declare one or more transformation functions (such as `lookUpTodo`) that should be used in the mapping. In the final step, we call `con.connect` to create the `get` properties that perform the declared mappings.
+The Connector instance allows you to map data from one object onto another object.
+In our example, the `data.inputs.todos` field is mapped onto the `todos.filtering.inputItems` field. What this means is that `Connector` turns `todos.filtering.inputItems` into a `get` property that returns `data.inputs.todos`.
 
 ### Logging
 
-By calling `setOptions({logging: true})`, the SkandhaJS library allows you to inspect each facet before and
-after calling an operation. An operation is any facet member function decorated with @operation.
-This will log Facet members that are decorated with `@data` (or `@input`, or `@output`) in a way that looks similar to what you are used to from Redux:
+By calling `setOptions({logging: true})`, the SkandhaJS library allows you to inspect each facet before and after calling an operation.
+All facet members that are decorated with `@data` (or `@input`, or `@output`) are logged in a way that looks similar to what you are used to from Redux:
 
 - before and after each operation, the entire container that holds the facet is logged
 - all data members of each facet in the container are included in the log
@@ -279,15 +265,13 @@ This will log Facet members that are decorated with `@data` (or `@input`, or `@o
 
 ### Making facets observable with Mobx
 
-If you want to render the facets with React then we need to let React know when data changes.
-The [skandha-mobx](http://github.com/mnieber/skandha-mobx) library was created for this purpose.
-It has a `registerCtr` function that turns each `@data` member into a Mobx property that is
+If you want to render the facets with React then we need to let React know when data changes. The [skandha-mobx](http://github.com/mnieber/skandha-mobx) library was created for this purpose. It has a `registerCtr` function that turns each `@data` member into a Mobx property that is
 either observable or computed:
 
 ```
 registerCtr({
   ctr: ctr,
-  options: { name: 'TodosCtr'},
+  options: { name: 'Todos'},
 });
 ```
 

package/lib/Connector.d.ts

@@ -1,5 +1,5 @@
-declare type FunctionByNameT = {
-    [name: string]: Function;
+declare type OptionsT = {
+    strict: boolean;
 };
-export declare const createConnector: (entities: FunctionByNameT) => any;
+export declare const createConnector: (obj: any, options?: OptionsT) => any;
 export {};

package/lib/Connector.js

@@ -1,11 +1,37 @@
 import { mapDataToProp } from './patch';
+function _path(path, obj) {
+    var result = obj;
+    for (var _i = 0, _a = path.split('.'); _i < _a.length; _i++) {
+        var part = _a[_i];
+        result = result === null || result === void 0 ? void 0 : result[part];
+        if (result === undefined)
+            return result;
+    }
+    return result;
+}
 var Connector = /** @class */ (function () {
-    function Connector(entities, options) {
+    function Connector(obj, options) {
         var _this = this;
         var _a;
-        this.entityByName = {};
+        this.entityByKey = {};
+        this.getOrCreateEntity = function (key) {
+            if (_this.entityByKey[key])
+                return _this.entityByKey[key];
+            var obj = _path(key, _this.obj);
+            var entity = new Proxy(new Entity(obj), {
+                get: function (target, key) {
+                    return target[key] || target.getOrCreateField(key);
+                },
+                set: function (target, key, value) {
+                    target.fieldByName[key] = value;
+                    return true;
+                },
+            });
+            _this.entityByKey[key] = entity;
+            return entity;
+        };
         this.connect = function () {
-            for (var _i = 0, _a = Object.values(_this.entityByName); _i < _a.length; _i++) {
+            for (var _i = 0, _a = Object.values(_this.entityByKey); _i < _a.length; _i++) {
                 var entity = _a[_i];
                 _this._connectEntity(entity);
             }
@@ -13,12 +39,11 @@ var Connector = /** @class */ (function () {
         this._connectEntity = function (entity) {
             var _loop_1 = function (entry) {
                 var name_1 = entry[0], field = entry[1];
-                var obj = entity.getObj();
-                if (_this.options.strict && !(name_1 in obj)) {
-                    throw new Error("Cannot override the field ".concat(name_1, " in ").concat(obj, ".") +
+                if (_this.options.strict && !(name_1 in entity.obj)) {
+                    throw new Error("Cannot override the field ".concat(name_1, " in ").concat(entity.obj, ".") +
                         'Field not found. Disable strict mode to ignore this error.');
                 }
-                mapDataToProp(obj, name_1, function () {
+                mapDataToProp(entity.obj, name_1, function () {
                     return field.getSource();
                 });
             };
@@ -30,64 +55,48 @@ var Connector = /** @class */ (function () {
         this.options = {
             strict: (_a = options === null || options === void 0 ? void 0 : options.strict) !== null && _a !== void 0 ? _a : true,
         };
-        for (var _i = 0, _b = Object.entries(entities); _i < _b.length; _i++) {
-            var entry = _b[_i];
-            var name_2 = entry[0], getObj = entry[1];
-            this.entityByName[name_2] = new Entity(getObj);
-        }
+        this.obj = obj;
     }
     return Connector;
 }());
-export var createConnector = function (entities) {
-    var con = new Connector(entities);
+export var createConnector = function (obj, options) {
+    var con = new Connector(obj, options);
     return new Proxy(con, {
         get: function (target, key) {
-            // Code example:
-            //
-            // const con = createConnector({ foo: () => myFoo });
-            //
-            // When you call `con.foo` then you
-            // receive `con.entityByName.foo.fieldByName`.
-            //
-            // con.foo.bar = 5;  // Equivalent to: con.entityByName.foo.fieldByName.bar = 5
-            //
-            // When you call `con.connect` then a normal lookup of the `connect`
-            // member in `con` is performed.
-            var _a, _b;
-            return (_b = (_a = target.entityByName[key]) === null || _a === void 0 ? void 0 : _a.fieldByName) !== null && _b !== void 0 ? _b : target[key];
+            var _a;
+            return (_a = target[key]) !== null && _a !== void 0 ? _a : target.getOrCreateEntity(key);
         },
     });
 };
 var Entity = /** @class */ (function () {
-    function Entity(getObj) {
+    function Entity(obj) {
         var _this = this;
-        this.getObj = getObj;
-        this.fieldByName = new Proxy({}, {
-            get: function (target, key) {
-                var _a;
-                return (_a = target[key]) !== null && _a !== void 0 ? _a : new Field(_this, key);
-            },
-        });
+        this.fieldByName = {};
+        this.getOrCreateField = function (name) {
+            var _a;
+            // If we create a new field then we should *not* store it in fieldByName.
+            return (_a = _this.fieldByName[name]) !== null && _a !== void 0 ? _a : new Field(_this.obj, name);
+        };
+        this.obj = obj;
     }
     return Entity;
 }());
 var Field = /** @class */ (function () {
-    function Field(entity, name) {
+    function Field(obj, name) {
         var _this = this;
         this.transforms = [];
         this.getSource = function () {
-            var obj = _this.entity.getObj();
-            if (!(_this.name in obj)) {
-                throw new Error("Field ".concat(_this.name, " does not exist on object ").concat(obj));
+            if (!(_this.name in _this.obj)) {
+                throw new Error("Field ".concat(_this.name, " does not exist on object ").concat(_this.obj));
             }
-            var result = obj[_this.name];
+            var result = _this.obj[_this.name];
             for (var _i = 0, _a = _this.transforms; _i < _a.length; _i++) {
                 var tf = _a[_i];
                 result = tf(result);
             }
             return result;
         };
-        this.entity = entity;
+        this.obj = obj;
         this.name = name;
     }
     Field.prototype.tf = function (transform) {

package/lib/registerCtr.d.ts

@@ -1,6 +1,6 @@
 export declare type OptionsT = {
     name: string;
-    members?: string[];
+    facets?: string[];
     ctrState?: Function;
 };
 export declare function registerCtr(ctr: any, options: OptionsT): void;

package/lib/registerCtr.js

@@ -10,12 +10,12 @@ export function registerCtr(ctr, options) {
     ctrAdmin.facetMembers = (_a = ctrAdmin.facetMembers) !== null && _a !== void 0 ? _a : [];
     ctrAdmin.facetByFacetClassName = (_b = ctrAdmin.facetByFacetClassName) !== null && _b !== void 0 ? _b : {};
     ctrAdmin.ctrStateOverride = options.ctrState;
-    ((_c = options.members) !== null && _c !== void 0 ? _c : Object.getOwnPropertyNames(ctr)).forEach(function (member) {
-        var facet = ctr[member];
+    ((_c = options.facets) !== null && _c !== void 0 ? _c : Object.getOwnPropertyNames(ctr)).forEach(function (facetName) {
+        var facet = ctr[facetName];
         setCtr(facet, ctr);
-        ctrAdmin.facetMembers.push(member);
+        ctrAdmin.facetMembers.push(facetName);
         if (!facet.constructor.className) {
-            console.error("Facet ".concat(member, " of container ").concat(ctrAdmin.logName, " ") +
+            console.error("Facet ".concat(facetName, " of container ").concat(ctrAdmin.logName, " ") +
                 "does not have a static className function");
         }
         var className = facetClassName(facet.constructor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skandha",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Create data containers with modular behaviours",
   "main": "index.js",
   "repository": "https://github.com/mnieber/skandha.git",