skandha 0.10.1 → 0.11.0

package/README.md

@@ -1,8 +1,23 @@
 # SkandhaJS
 
-## Rationale
+## Introduction
 
-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.
+SkandhaJS is a library that provides data containers with reusable behaviors, or "facets," that are implemented as classes. Examples of facets are selection, highlighting, filtering, drag-and-drop, etc. These facets provide interfaces for specific behaviors and rely on callback functions provided by the programmer to specify the details of those behaviors. The goal of SkandhaJS is to provide a way to create interactions between different behaviors in a consistent and modular way.
+
+As a brief illustration, consider the example of selecting a todo in a list of todos:
+
+1. The application has a local state with a list of todos. The state contains a `todoSelection` facet so that clients can make a selection.
+2. When the user clicks on a todo, the todo-list component calls `todoSelection.selectItem(todo.id, shift, ctrl)`.
+3. The `todoSelection.selectItem` function runs the `select` function from its `callbackMap`.
+4. The `select` callback performs the selection and a side-effect: it highlights the item as well.
+
+## Benefits
+
+There are three ways in which facets help you to write generic code:
+
+1. They can be reused in any container, regardless of what data-type is stored in the container. This means that selection, filtering and drag-and-drop work the same everywhere in the application.
+2. They allow you to capture the interaction between behaviours in reusable functions.
+3. They allow you to handle user-interaction in UI components in a uniform way. All UI components that receive a selection facet will use the same interface to make a selection (and in theory the component can remain agnostic of how selection works, or even of the type of items that are being selected).
 
 ## Links
 
@@ -15,64 +30,88 @@ The goal of SkandhaJS is to provide data containers that have reusable behaviors
 ## Glossary (conceptual)
 
 - callback function: a function that is called by an operation to help implement that operation
-- callbacks object: a collection of callback functions that is used by an operation.
-- container: a class that contains multiple facets. Typically, these facets are made to work together using callback functions.
+- callbackMap object: a collection of callback functions that is used by an operation.
+- container: an object that contains data and facets. Typically, these facets are made to work together using callback functions.
 - 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.
-- mapDataToProps: a helper function that maps data from one object to another. It's also used to map data between facets.
+- mapDataToProps: a helper function that maps data from one object to another. It's used to map data between facets.
 - registerCtr: the function that tells SkandhaJS which containers and facets exist.
-- setCallbackMap: the function that installs the callbacks objects that are used by a facet.
+- setCallbackMap: the function that installs the callbackMap objects that are used by a facet.
 
-## Example: a simplified Selection facet
+## Example: a 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.
+In Skandha, a behaviour such as selection is implemented in a "facet" class. The purpose of the selection facet is to store (and manipulate) the meta-data related to selection. In this example, we will show a simplified Selection facet class.
 
 ```
 // file: Selection.ts
 import { input, output, operation } from 'skandha';
-
-export type SelectionParamsT = { itemId?: string; isShift?: boolean; isCtrl?: boolean; };
+import { DefineCbs, getCallbacks, withCbs, stub } from 'aspiration';
 
 export class Selection<ValueT = any> {
   static className = () => 'Selection';
 
-  @input selectableIds: Array<string> = [];
+  @input selectableIds: Array<string> = stub();
   @output ids: Array<string> = [];
   @output anchorId?: string;
-  @output items: Array<ValueT> = [];
+  @output items: Array<ValueT> = stub();
 
-  @operation selectItem(selectionParams: SelectionParamsT) {
-    // This function calls a callback function to do the actual work.
-    // Details about how this works are omitted for now.
+  @operation @withCbs() selectItem(args: SelectionParamsT) {
+    const cbs = getCallbacks(this) as SelectionCbs['selectItem'];
+    cbs.select();
   }
 }
+
+type Cbs<T> = {
+  selectItem: {
+    selectItem(): void;
+  };
+};
+
+export type SelectionCbs<T = any> = DefineCbs<Selection<T>, Cbs<T>>;
 ```
 
-## Fact: facets have @input, @data and @output members
+## Facets have @input, @data and @output members
+
+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. The `@input` decorator marks this field as an input. The `ids`, `anchorId` and `items` fields store the result of calling `selectItem()` and are marked as `@output` fields. Fields that are decorated with `@data` are used both as output and input. These decorators help with logging, and they also make it possible to bind the facets to state-management solutions such as MobX.
+
+## Operations are decorated with `@operation`.
+
+The `Selection` facet has a `selectItem()` 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. This design leaves the selection method (e.g. what should happen if shift is pressed?) up to the client, which makes it possible to support different use-cases flexibly.
+
+## Operations are logged
 
-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()`. Fields that are decorated with `@data` are used both as output and input.
+As a side effect of calling an operation, the entire container is logged to the console (if logging is enabled); this includes the Selection facet, and any other facets that the container may have (such as filtering, or highlight). The log message contains all @input, @data and @output fields of all facets in the container.
 
-## Fact: operations are decorated with `@operation`.
+## The `@withCbs` decorator is used to enable callbacks in an operation.
 
-The `Selection` facet has a `selectItem()` 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.
+The `@withCbs` decorator comes from the `Aspiration` library. When you call a function `f` that is decorated with `@withCbs` then the following happens:
 
-## Fact: operations are logged
+- Aspiration looks up the callbackMap object (that was installed with `setCallbackMap()`) for the given operation;
+- it copies the operation arguments to the callbackMap object, so that callback functions can access these arguments;
+- if calls `f(arguments)`, which internally calls the installed callback functions;
+- it restores the callbackMap object to its previous state. This ensures that nested calls work correctly.
 
-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 (such as filtering, or highlight). The log message contains all @input, @data and @output fields of all facets in the container.
+If the original function `f` wants to access the callbackMap object then it uses the `getCallbacks` helper function. Note that the client code calls `f` in the usual way; it remains agnostic of the fact that callbacks are used to help implement `f`.
+
+## Facets have a static `className()` function
+
+To allow SkandhaJS to log the container, you need to add the `className()` function to each facet class, so that Skandha knows the name of the facet.
+The `className()` function is also used to look up facets in containers. Note that if you subclass a facet class then you should (in most cases)
+not override the `className()`. By keeping the original `className()` function, you will be able to replace facets with their subclassed versions without affecting the facet lookup mechanism.
 
 ## Example: a container with Selection, Highlight and Filtering
 
 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 (and some other facets that we haven't defined yet).
+In this example we will take a look at a todos container. It uses the `Selection` facet that we saw earlier (and some other facets that we haven't defined yet). Note that in this example, we're not yet storing any data in the container (this will come later).
 
 ```
 // file: createContainer.ts
-import { Selection_selectItem } from 'SelectionCbs';
+import { SelectionCbs } from 'SelectionCbs';
+import * as R from 'ramda';
 
 const createContainer() {
   const todosCtr = {
@@ -83,13 +122,15 @@ const createContainer() {
 
   setCallbackMap(todosCtr.selection, {
     selectItem: {
-      select(this: Selection_selectItem): {
-        handleSelectItem(todosCtr.selection, this.selectionParams);
-        highlightFollowsSelection(todosCtr, this.selectionParams);
+      select(this: SelectionCbs['selectItem']): {
+        handleSelectItem(todosCtr.selection, this.args);
+        highlightFollowsSelection(todosCtr, this.args);
       },
     }
   });
 
+  setCallbackMap(todosCtr.highlight, {});
+
   setCallbackMap(todosCtr.filtering, {
     apply: {
       exit() {
@@ -141,156 +182,89 @@ export function handleSelectItem(
 }
 ```
 
-## Note: the todos container has selection, highlight and filtering
-
-In `createContainer.ts` we see how `createContainer()` creates a `todosCtr` 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. In this case, we only install the `select()` callback function.
+## Callbacks are installed with `setCallbackMap()`
 
-## Fact: callbacks are installed with `setCallbackMap()`
+We call `setCallbackMap()` to install a callbackMap object for each operation of the `Selection` facet. 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 `setCallbackMap()` to be as short and readable as possible, so that it's easy to understand what happens in each operation of each facet.
 
-We call `setCallbackMap()` to install a callbacks object for each operation of the `Selection` facet. 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 `setCallbackMap()` to be as short and readable as possible, so that it's easy to understand what happens in each operation of each facet.
+## The callback function can access the callbackMap object through `this`.
 
-## Fact: callbacks can take care of side effects
+When the clients calls `todosCtr.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.args`. See the `aspiration` library documentation for details.
 
-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.
+## Callbacks can take care of side effects
 
-## Fact: the callback function can access the callbacks object through `this`.
+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. Keeping the code of `setCallbackMap()` short also helps the reader to understand which interactions take place. This is vital, because we are purposely mixing concerns in this part of the code, which means that there is a higher risk of confusing the reader.
 
-When the clients calls `todosCtr.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`.
+## The `exit()` callback function is called at the end of an operation
 
-## Fact: the `exit()` callback function is called at the end of an operation
+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 automatically at the beginning.
 
-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.
+## The `registerCtr()` allows SkandhaJS to introspect the container
 
-## Fact: the `registerCtr()` allows SkandhaJS to introspect the container
+At the end of `createContainer.ts` we call `registerCtr()` so that SkandhaJS can 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(todosCtr, Selection)` returns `todosCtr.selection`. Second, it informs SkandhaJS how to log all facets of the container.
 
-At the end of `createContainer.ts` we call `registerCtr()` so that SkandhaJS can 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(todosCtr, Selection)` returns `todosCtr.selection`. Second, it informs SkandhaJS how to log all facets of the container
-
-## Example: a complete Selection facet
+## Example: `mapDataToProps()` maps data onto each facet
 
-It's time now to return to the Selection facet and show how callbacks really work.
+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. The next step is to map data between facets. Such mappings are necessary when the input data for one facet is based on the output data of another facet. For example, we should only allow selection of todos that have not been filtered out. In this example, we will see how we can create such a mapping. Moreover, we will add code to load the todos and set them as the inputs of the filtering facet.
 
 ```
-// file: Selection.ts
-import { input, output, operation } from 'skandha';
-import { host, stub } from 'aspiration';
-import { Selection_selectItem, SelectionParamsT } from 'SelectionCbs';
+// file: createContainer.ts
+import * from 'ramda' as R;
+import { mapDataToProps } from 'skandha';
 
-export class Selection<ValueT = any> {
-  static className = () => 'Selection';
+class TodosData {
+  static className = () => 'Inputs';
 
-  @input selectableIds: Array<string> = stub();
-  @output ids: Array<string> = [];
-  @output anchorId?: string;
-  @output items: Array<ValueT> = stub();
+  @data todos: TodoT[] = [];
+  @data filteredTodos: TodoT[] = [];
 
-  @operation @host(['selectionParams']) selectItem(
-    selectionParams: SelectionParamsT
-  ) {
-    return (cbs: Selection_selectItem) => {
-      cbs.select();
-    };
+  @data get todoById() {
+    return R.indexBy(R.prop('id'), todosCtr);
   }
 }
-```
-
-```
-// file: SelectionCbs.ts
-import { stub } from 'aspiration';
-
-export type SelectionParamsT = { itemId?: string; isShift?: boolean; isCtrl?: boolean; };
-
-export class Selection_selectItem extends Cbs {
-  selectionParams: SelectionParamsT = stub();
-  select() {}
-}
-```
-
-## 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 `setCallbackMap()`)
-- 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
-
-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.
-
-## Example: `mapDataToProps()` 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. In this example, we will see how we can create such a mapping from the filtering facet to the selection facet. Moreover, we will add code to load the todos and set them as the inputs of the filtering facet.
-
-```
-// file: createContainer.ts
-import * from 'ramda' as R;
-import { mapDataToProps, pmap } from 'skandha';
 
 const createContainer = () => {
   const todosCtr = {
-    data: {
-      todos: loadTodos(),
-      filteredTodoById: {},
-    },
+    data: new TodosData(),
     selection: new Selection(),
     highlight: new Highlight(),
     filtering: new Filtering(),
   }
+  todosCtr.data.todos = loadTodos();
+  const getTodoById = (id?: string) => id ? todosCtr.data.todoById[id] : undefined;
 
-  const lookUpTodo = (id?: string) => id ? todosCtr.data.filteredTodoById[id] : undefined;
-
-  mapDataToProps(
-    pmap(
-      [todosCtr.filtering, 'inputItems'],
-      () => todosCtr.data.todos
-    ),
-    pmap(
-      [todosCtr.data, 'filteredTodoById'],
-      () => R.indexBy('id')(todosCtr.filtering.filteredItems)
-    ),
-    pmap(
-      [todosCtr.selection, 'selectableIds'],
-      () => R.keys(todosCtr.data.filteredTodoById)
-    ),
-    pmap(
-      [todosCtr.selection, 'item'],
-      () => R.map(lookUpTodo, todosCtr.selection.ids)
-    ),
-    pmap(
-      [todosCtr.highlight, 'item'],
-      () => lookUpTodo(todosCtr.highlight.id)
-    ),
+  mapDataToProps(todosCtr,
+    filtering: {
+      inputItems: () => todosCtr.data.todos,
+      filteredItems: () => todosCtr.filtering.filteredItems,
+    },
+    selection: {
+      selectableIds: () => R.map(R.prop('id'), todosCtr.data.filteredTodos),
+      items: () => R.map(getTodoById, todosCtr.selection.ids),
+    },
+    highlight: {
+      item: () => getTodoById(todosCtr.highlight.id)
+    }
   )
 }
 
 setOptions({logging: true});
 ```
 
-## Fact: the `mapDataToProps()` function maps data between objects
-
-The `mapDataToProp()` function takes a container, field name and function then it turns that field into a `get` property that executes the given function. The `mapDataToProps()` is a small convenience function that calls `mapDataToProp()` on each of its arguments. In our example, we see that the `todosCtr.data.todos` field is mapped onto the `todosCtr.filtering.inputItems` field.
-
-## Fact: the `pmap()` function adds type-checking
+## The `mapDataToProps()` function maps data between objects
 
-The `pmap()` function takes two arguments. The first argument is an array that has a container and a container-member. The second argument is a function. The `pmap` function checks that the output of this function can be stored in the container-member (if not, then a compile-time error results). It returns an array that contains its two arguments (because that is the format that `mapDataToProps` expects). As you can see, `pmap` does not do any useful work at run-time, but it adds type-checking at compile-time.
+The `mapDataToProp()` function takes a container, field name and function and installs a `get` property (on the given container, using the given field name) that executes the given function. In our example, we see that the `todosCtr.data.todos` field is mapped onto the `todosCtr.filtering.inputItems` field.
 
-## Fact: logging can be enabled using `setOptions()`
+## Logging can be enabled using `setOptions()`
 
-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:
+If you call `setOptions({logging: true})` then the SkandhaJS library logs each facet before and after each operation. All facet members that are decorated with `@data` (or `@input`, or `@output`) are logged in a way similar to 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
 - log entries are nested so that you can see how operation calls are nested
 
-## Fact: the `registerCtr()` function from facets-mobx makes facets observable
+## The `registerCtr()` function from facets-mobx makes facets observable
 
-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 can be used instead of the default one from `skandha`. This replacement version of `registerCtr()` function turns each `@data` member into a Mobx property that is either observable or computed.
+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 can be used instead of the default one from `skandha`. This drop-in replacement version of the normal `registerCtr()` function turns each `@data` member into a Mobx property that is either observable or computed.
 
 ## Conclusion
 
@@ -301,5 +275,4 @@ separating concerns in a clear and understandable way. We could add a `Editing`
 a policy that says that changing the highlight disables editing. By using facets, we will not be tempted to put
 editing-specific code directly in the highlight function (that would obviously be mixing concerns).
 
-In my experience, using SkandhaJS leads to code reuse and improved structure. On top of that, it offers a good
-debugging experience by logging all changes in the container. Finally, it works nicely with MobX to render the container contents.
+In my experience, using SkandhaJS leads to code reuse and improved structure. On top of that, it offers a good debugging experience by logging all changes in the container. Finally, it works nicely with MobX to render the container contents.

package/index.d.ts

@@ -1,11 +1,11 @@
 export { getCtrState } from './internal/logging';
-export { getOptions, setOptions } from './internal/options';
-export { getc, getFacetMemberNames } from './lib/ctr';
+export { decorateCb, getOptions, setOptions } from './internal/options';
+export { getFacetMemberNames, getc } from './lib/ctr';
 export { data, getDataMemberNames, getLoggedMemberNames, input, log, output, } from './lib/data';
 export { getf } from './lib/facet';
 export { installPolicies } from './lib/install';
 export { getOperationMemberNames, operation } from './lib/operation';
-export { mapDataToProp, mapDataToProps, pmap } from './lib/patch';
+export { mapDataToProp, mapDataToProps } from './lib/patch';
 export { registerCtr } from './lib/registerCtr';
 export type { OptionsT as RegisterCtrOptionsT } from './lib/registerCtr';
-export declare type ClassT = any;
+export type ClassT = any;

package/index.js

@@ -1,9 +1,9 @@
 export { getCtrState } from './internal/logging';
-export { getOptions, setOptions } from './internal/options';
-export { getc, getFacetMemberNames } from './lib/ctr';
+export { decorateCb, getOptions, setOptions } from './internal/options';
+export { getFacetMemberNames, getc } from './lib/ctr';
 export { data, getDataMemberNames, getLoggedMemberNames, input, log, output, } from './lib/data';
 export { getf } from './lib/facet';
 export { installPolicies } from './lib/install';
 export { getOperationMemberNames, operation } from './lib/operation';
-export { mapDataToProp, mapDataToProps, pmap } from './lib/patch';
+export { mapDataToProp, mapDataToProps } from './lib/patch';
 export { registerCtr } from './lib/registerCtr';

package/internal/options.d.ts

@@ -1,9 +1,12 @@
 export declare const options: {
     logging: boolean;
     formatObject: (x: any) => any;
+    decorateCb: (x: any) => any;
 };
 export declare const getOptions: () => {
     logging: boolean;
     formatObject: (x: any) => any;
+    decorateCb: (x: any) => any;
 };
 export declare const setOptions: (moreOptions: any) => void;
+export declare const decorateCb: (x: any) => any;

package/internal/options.js

@@ -1,8 +1,10 @@
 export var options = {
     logging: false,
     formatObject: function (x) { return x; },
+    decorateCb: function (x) { return x; },
 };
 export var getOptions = function () { return options; };
 export var setOptions = function (moreOptions) {
     Object.assign(options, moreOptions);
 };
+export var decorateCb = function (x) { return options.decorateCb(x); };

package/internal/utils.js

@@ -1,7 +1,11 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { symbols } from './symbols';
 export function getOrCreate(obj, key, fn) {
@@ -16,7 +20,7 @@ export var zip = function (arr) {
         arrs[_i - 1] = arguments[_i];
     }
     return arr.map(function (val, i) {
-        return arrs.reduce(function (a, arr) { return __spreadArray(__spreadArray([], a), [arr[i]]); }, [val]);
+        return arrs.reduce(function (a, arr) { return __spreadArray(__spreadArray([], a, true), [arr[i]], false); }, [val]);
     });
 };
 export function getCtrAdmin(ctr) {

package/lib/facet.js

@@ -11,7 +11,7 @@ export function getf(facetClass, ctr) {
         : (_a = getCtrAdmin(ctr).facetByFacetClassName) === null || _a === void 0 ? void 0 : _a[facetClassName(facetClass)];
     if (!facet) {
         var facetName = facetClass === 'string' ? facetClass : facetClassName(facetClass);
-        console.error("No facet " + facetName + " in container " + getCtrAdmin(ctr).logName);
+        console.error("No facet ".concat(facetName, " in container ").concat(getCtrAdmin(ctr).logName));
     }
     return facet;
 }

package/lib/operation.js

@@ -13,7 +13,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/patch.d.ts

@@ -1,3 +1,8 @@
 export declare function mapDataToProp<F, P extends keyof F>(facet: F, prop: P, getter: () => F[P]): void;
-export declare function mapDataToProps(...mappings: any[]): void;
-export declare function pmap<F, P extends keyof F>(member: [F, P], getter: () => F[P]): ([F, P] | (() => F[P]))[];
+type Mappings<F> = {
+    [K in keyof F]?: {
+        [P in keyof F[K]]?: () => F[K][P];
+    };
+};
+export declare function mapDataToProps<T>(target: T, mappings: Mappings<T>): void;
+export {};

package/lib/patch.js

@@ -6,16 +6,21 @@ export function mapDataToProp(facet, prop, getter) {
         configurable: true,
     });
 }
-export function mapDataToProps() {
-    var mappings = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        mappings[_i] = arguments[_i];
+export function mapDataToProps(target, mappings) {
+    for (var key in mappings) {
+        if (mappings.hasOwnProperty(key)) {
+            var facet = target[key];
+            var propMappings = mappings[key];
+            if (facet && propMappings) {
+                for (var prop in propMappings) {
+                    if (propMappings.hasOwnProperty(prop)) {
+                        var getter = propMappings[prop];
+                        if (getter) {
+                            mapDataToProp(facet, prop, getter);
+                        }
+                    }
+                }
+            }
+        }
     }
-    for (var _a = 0, mappings_1 = mappings; _a < mappings_1.length; _a++) {
-        var mapping = mappings_1[_a];
-        mapDataToProp(mapping[0][0], mapping[0][1], mapping[1]);
-    }
-}
-export function pmap(member, getter) {
-    return [member, getter];
 }

package/lib/registerCtr.d.ts

@@ -1,4 +1,4 @@
-export declare type OptionsT = {
+export type OptionsT = {
     name: string;
     facets?: string[];
     ctrState?: Function;

package/lib/registerCtr.js

@@ -15,13 +15,13 @@ export function registerCtr(ctr, options) {
         setCtr(facet, ctr);
         ctrAdmin.facetMembers.push(facetName);
         if (!facet.constructor.className) {
-            console.error("Facet " + facetName + " of container " + ctrAdmin.logName + " " +
+            console.error("Facet ".concat(facetName, " of container ").concat(ctrAdmin.logName, " ") +
                 "does not have a static className function");
         }
         var className = facetClassName(facet.constructor);
-        getFacetAdmin(facet).logName = ctrAdmin.logName + "/" + className;
+        getFacetAdmin(facet).logName = "".concat(ctrAdmin.logName, "/").concat(className);
         if (ctrAdmin.facetByFacetClassName[className] !== undefined) {
-            console.error("Two facets of same type " + className + " in container " + ctrAdmin.logName);
+            console.error("Two facets of same type ".concat(className, " in container ").concat(ctrAdmin.logName));
         }
         ctrAdmin.facetByFacetClassName[className] = facet;
     });

package/package.json

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