skandha 0.10.2 → 0.12.0

package/README.md

@@ -2,22 +2,14 @@
 
 ## Introduction
 
-The goal of SkandhaJS is to provide data containers that have reusable behaviors. These behaviours are implemented in classes called "facets". Examples of facets are selection, highlighting, filtering, drag-and-drop, etc. By connecting these facets, you can create interactions between different behaviours.
-
-Every facet provides an interface that supports a particular behaviour. This interface is used throughout the application, and ensures that the basic mechanism (e.g. for doing selection) is the same everywhere. The details of the behaviour depend on callback functions that the programmer provides:
-
-1. Callbacks decide what exactly happens when an item is selected, highlighted, deleted etc.
-2. Callbacks implement interactions. For example: when selecting an item, also higlight it.
-
-The second point is important for limiting the mixing of concerns that happens when you are combining multiple behaviours. This mixing of concerns is unavoidable, but should be limited to specific places that can be easily inspected.
+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 creates a local state to store todos. This state contains a `todoSelection` facet.
+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 `aspiration` library intercepts the call in order to prepare a so-called `callbackMap`.
-4. Next, the `todoSelection.selectItem` function runs. It uses the `select` function from the `callbackMap` to do its work.
-5. The `select` callback performs the selection and a side-effect: it highlights the item as well.
+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
 
@@ -25,7 +17,7 @@ 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 the data-type of the selected items).
+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
 
@@ -57,8 +49,7 @@ In Skandha, a behaviour such as selection is implemented in a "facet" class. The
 ```
 // file: Selection.ts
 import { input, output, operation } from 'skandha';
-import { host, stub } from 'aspiration';
-import { Selection_selectItem, SelectionParamsT } from 'SelectionCbs';
+import { DefineCbs, getCallbacks, withCbs, stub } from 'aspiration';
 
 export class Selection<ValueT = any> {
   static className = () => 'Selection';
@@ -68,30 +59,24 @@ export class Selection<ValueT = any> {
   @output anchorId?: string;
   @output items: Array<ValueT> = stub();
 
-  @operation @host(['selectionParams']) selectItem(
-    selectionParams: SelectionParamsT
-  ) {
-    const cbs = getCallbacks<Selection_selectItem>(this);
+  @operation @withCbs() selectItem(args: SelectionParamsT) {
+    const cbs = getCallbacks(this) as SelectionCbs['selectItem'];
     cbs.select();
   }
 }
-```
 
-```
-// file: SelectionCbs.ts
-import { stub } from 'aspiration';
-
-export type SelectionParamsT = { itemId?: string; isShift?: boolean; isCtrl?: boolean; };
+type Cbs<T> = {
+  selectItem: {
+    selectItem(): void;
+  };
+};
 
-export class Selection_selectItem extends Cbs {
-  selectionParams: SelectionParamsT = stub();
-  select() {}
-}
+export type SelectionCbs<T = any> = DefineCbs<Selection<T>, Cbs<T>>;
 ```
 
 ## 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 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. These decorators help with logging, and they also make it possible to bind the facets to state-management solutions such as MobX.
+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`.
 
@@ -101,24 +86,38 @@ The `Selection` facet has a `selectItem()` operation that allows you to select f
 
 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.
 
-## The `@host` decorator is used to enable callbacks in an operation.
+## The `@withCbs` 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:
+The `@withCbs` decorator comes from the `Aspiration` library. When you call a function `f` that is decorated with `@withCbs` then the following happens:
 
 - 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)`;
+- 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.
 
 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`.
 
-## Callback functions have access to all operation arguments
-
-Each callback function of the callbackMap object has access to all arguments of the operation. In our example, the argument of the `selectItem` operation is named `selectionParams`. Therefore, a `selectionParams` field also exists in the `Selection_selectItem` class that stores the callbackMap. We must manually pass the list of argument names to the `@host` decorator, so that SkandhaJS can copy these values (unfortunately, introspection in typescript is not good enough to automate this).
-
 ## 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.
+
+## Facets that use inheritance must have a static `skandhaSymbol` member
+
+The skandhaSymbol member is a workaround for a change in Typescript that affects the
+`experimentalDecorators` feature. Add this member if the facet class inherits from some
+other class.
+
+```
+// file: Selection.ts
+import { Selection } from 'skandha-facets';
+
+export class MySelection extends Selection {
+  static className = () => 'MySelection';
+  static skandhaSymbol = Symbol('MySelection');
+}
+```
 
 ## Example: a container with Selection, Highlight and Filtering
 
@@ -127,7 +126,7 @@ In this example we will take a look at a todos container. It uses the `Selection
 
 ```
 // file: createContainer.ts
-import { Selection_selectItem } from 'SelectionCbs';
+import { SelectionCbs } from 'SelectionCbs';
 import * as R from 'ramda';
 
 const createContainer() {
@@ -139,9 +138,9 @@ 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);
       },
     }
   });
@@ -203,13 +202,13 @@ export function handleSelectItem(
 
 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.
 
-## Callbacks can take care of side effects
+## The callback function can access the callbackMap 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.args`. See the `aspiration` library documentation for details.
 
-## The callback function can access the callbackMap object through `this`.
+## 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.selectionParams`.
+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.
 
 ## The `exit()` callback function is called at the end of an operation
 
@@ -226,7 +225,7 @@ We've seen how facets are implemented, and how they can be added to a container
 ```
 // file: createContainer.ts
 import * from 'ramda' as R;
-import { mapDataToProps, pmap } from 'skandha';
+import { mapDataToProps } from 'skandha';
 
 class TodosData {
   static className = () => 'Inputs';
@@ -247,30 +246,20 @@ const createContainer = () => {
     filtering: new Filtering(),
   }
   todosCtr.data.todos = loadTodos();
-
   const getTodoById = (id?: string) => id ? todosCtr.data.todoById[id] : undefined;
 
-  mapDataToProps(
-    pmap(
-      [todosCtr.filtering, 'inputItems'],
-      () => todosCtr.data.todos
-    ),
-    pmap(
-      [todosCtr.data, 'filteredTodos'],
-      () => todosCtr.filtering.filteredItems
-    ),
-    pmap(
-      [todosCtr.selection, 'selectableIds'],
-      () => R.map(R.prop('id'), todosCtr.data.filteredTodos)
-    ),
-    pmap(
-      [todosCtr.selection, 'items'],
-      () => R.map(getTodoById, todosCtr.selection.ids)
-    ),
-    pmap(
-      [todosCtr.highlight, 'item'],
-      () => getTodoById(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)
+    }
   )
 }
 
@@ -279,15 +268,11 @@ setOptions({logging: true});
 
 ## The `mapDataToProps()` function maps data between objects
 
-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. 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.
-
-## The `pmap()` function adds type-checking
-
-The `pmap` function does not really do anything at run-time, but it adds type-checking at compile-time. It 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).
+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.
 
 ## Logging can be enabled using `setOptions()`
 
-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 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

package/index.d.ts

@@ -1,11 +1,12 @@
 export { getCtrState } from './internal/logging';
-export { decorateCb, getOptions, setOptions } from './internal/options';
-export { getc, getFacetMemberNames } from './lib/ctr';
+export { getOptions, setOptions } from './internal/options';
+export { addCleanUpFunctionToCtr, cleanUpCtr } from './lib/cleanUp';
+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,10 @@
 export { getCtrState } from './internal/logging';
-export { decorateCb, getOptions, setOptions } from './internal/options';
-export { getc, getFacetMemberNames } from './lib/ctr';
+export { getOptions, setOptions } from './internal/options';
+export { addCleanUpFunctionToCtr, cleanUpCtr } from './lib/cleanUp';
+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/logging.js

@@ -1,21 +1,10 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { getCtrAdmin, getFacetAdmin } from '../internal/utils';
-import { getc, getFacetMemberNames } from '../lib/ctr';
+import { getFacetMemberNames, getc } from '../lib/ctr';
 import { getLoggedMemberNames } from '../lib/data';
 import { options } from './options';
 export function _defaultFacetLogName(facet) {
-    var ctr = getc(facet);
-    var prefix = ctr ? ctr.constructor.name + '/' : '';
+    const ctr = getc(facet);
+    const prefix = ctr ? ctr.constructor.name + '/' : '';
     return prefix + facet.constructor.name;
 }
 export function facetLogName(facet) {
@@ -29,41 +18,39 @@ function camelToSnake(string) {
     })
         .toLowerCase();
 }
-var opName = function (operationMember) { return camelToSnake(operationMember).toUpperCase(); };
+const opName = (operationMember) => camelToSnake(operationMember).toUpperCase();
 export function log(facet, operationMember, args, start) {
-    var ctr = getc(facet);
-    var getState = ctr ? function () { return getCtrState(ctr); } : function () { return facetState(facet); };
-    var operationName = opName(operationMember);
-    var label = facetLogName(facet) + '.' + operationName;
+    const ctr = getc(facet);
+    const getState = ctr ? () => getCtrState(ctr) : () => facetState(facet);
+    const operationName = opName(operationMember);
+    const label = facetLogName(facet) + '.' + operationName;
     if (start) {
         console.group(label);
-        console.log('%c           args: ', 'color: gray', args);
-        console.log('%c     state', 'color: gray', getState());
+        console.log('%c args: ', 'color: gray', args);
+        console.log('%c state', 'color: gray', getState());
     }
     else {
-        console.log('%c     next', 'color: gray', getState());
+        console.log('%c next', 'color: gray', getState());
         // @ts-ignore
         console.groupEnd(label);
     }
 }
 export function facetState(facet) {
-    return getLoggedMemberNames(facet).reduce(function (acc, loggedMember) {
-        var _a;
+    return getLoggedMemberNames(facet).reduce((acc, loggedMember) => {
         try {
-            var data = options.formatObject(facet[loggedMember]);
-            return __assign(__assign({}, acc), (_a = {}, _a[loggedMember] = data, _a));
+            const data = options.formatObject(facet[loggedMember]);
+            return Object.assign(Object.assign({}, acc), { [loggedMember]: data });
         }
-        catch (_b) {
+        catch (_a) {
             return acc;
         }
     }, {});
 }
 export function defaultGetCtrState(ctr) {
     if (ctr) {
-        return getFacetMemberNames(ctr).reduce(function (acc, facetMemberName) {
-            var _a;
-            var facet = ctr[facetMemberName];
-            return __assign(__assign({}, acc), (_a = {}, _a[facetMemberName] = facetState(facet), _a));
+        return getFacetMemberNames(ctr).reduce((acc, facetMemberName) => {
+            const facet = ctr[facetMemberName];
+            return Object.assign(Object.assign({}, acc), { [facetMemberName]: facetState(facet) });
         }, {});
     }
 }

package/internal/options.d.ts

@@ -1,12 +1,9 @@
 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,10 +1,8 @@
-export var options = {
+export const options = {
     logging: false,
-    formatObject: function (x) { return x; },
-    decorateCb: function (x) { return x; },
+    formatObject: (x) => x,
 };
-export var getOptions = function () { return options; };
-export var setOptions = function (moreOptions) {
+export const getOptions = () => options;
+export const setOptions = (moreOptions) => {
     Object.assign(options, moreOptions);
 };
-export var decorateCb = function (x) { return options.decorateCb(x); };

package/internal/symbols.js

@@ -1,3 +1,3 @@
-export var symbols = {
+export const symbols = {
     admin: Symbol('skandha administration'),
 };

package/internal/utils.js

@@ -1,34 +1,67 @@
-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';
+// This class is a workaround for a problem that occurs when you
+// try to store information using facet.constructor[symbols.admin] = ...
+// For some reason, when you inherit from a Facet class then the original
+// class and the enherited class share the same facet.constructor[symbols.admin]
+// instance.
+const facetClassAdminMap = new WeakMap();
 export function getOrCreate(obj, key, fn) {
     if (!obj[key]) {
         obj[key] = fn();
     }
     return obj[key];
 }
-export var zip = function (arr) {
-    var arrs = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        arrs[_i - 1] = arguments[_i];
-    }
-    return arr.map(function (val, i) {
-        return arrs.reduce(function (a, arr) { return __spreadArray(__spreadArray([], a, true), [arr[i]], false); }, [val]);
-    });
+export const zip = (arr, ...arrs) => {
+    return arr.map((val, i) => arrs.reduce((a, arr) => [...a, arr[i]], [val]));
 };
 export function getCtrAdmin(ctr) {
-    return getOrCreate(ctr, symbols.admin, function () { return ({}); });
+    return getOrCreate(ctr, symbols.admin, () => ({}));
 }
 export function getFacetClassAdmin(facetClass) {
-    return getOrCreate(facetClass, symbols.admin, function () { return ({}); });
+    if (!!facetClass.skandhaSymbol) {
+        return getOrCreate(facetClassAdminMap, facetClass.skandhaSymbol, () => {
+            // This function returns the initial value for the facetClassAdminMap.
+            // If the facetClass has a superClass, then we return a copy of the
+            // facetClassAdmin of the superClass.
+            const superClass = Object.getPrototypeOf(facetClass);
+            if (superClass !== Function.prototype && superClass !== null) {
+                return deepCopy(getFacetClassAdmin(superClass));
+            }
+            return {};
+        });
+    }
+    return getOrCreate(facetClass, symbols.admin, () => ({}));
 }
 export function getFacetAdmin(facet) {
-    return getOrCreate(facet, symbols.admin, function () { return ({}); });
+    return getOrCreate(facet, symbols.admin, () => ({}));
+}
+function deepCopy(obj) {
+    var copy;
+    // Handle the 3 simple types, and null or undefined
+    if (null == obj || 'object' != typeof obj)
+        return obj;
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+    // Handle Array
+    if (obj instanceof Array) {
+        copy = [];
+        for (var i = 0, len = obj.length; i < len; i++) {
+            copy[i] = deepCopy(obj[i]);
+        }
+        return copy;
+    }
+    // Handle Object
+    if (obj instanceof Object) {
+        copy = {};
+        for (var attr in obj) {
+            if (obj.hasOwnProperty(attr))
+                copy[attr] = deepCopy(obj[attr]);
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
 }

package/lib/cleanUp.d.ts

@@ -0,0 +1,2 @@
+export declare function addCleanUpFunctionToCtr(ctr: any, f: Function): void;
+export declare function cleanUpCtr(ctr: any): void;

package/lib/cleanUp.js

@@ -0,0 +1,14 @@
+import { getCtrAdmin } from '../internal/utils';
+export function addCleanUpFunctionToCtr(ctr, f) {
+    var _a;
+    const ctrAdmin = getCtrAdmin(ctr);
+    ctrAdmin.cleanUpFunctions = (_a = ctrAdmin.cleanUpFunctions) !== null && _a !== void 0 ? _a : [];
+    ctrAdmin.cleanUpFunctions.push(f);
+}
+export function cleanUpCtr(ctr) {
+    var _a;
+    const ctrAdmin = getCtrAdmin(ctr);
+    ctrAdmin.cleanUpFunctions = (_a = ctrAdmin.cleanUpFunctions) !== null && _a !== void 0 ? _a : [];
+    ctrAdmin.cleanUpFunctions.forEach((x) => x());
+    ctrAdmin.cleanUpFunctions = [];
+}

package/lib/data.js

@@ -1,16 +1,14 @@
 import { getFacetClassAdmin } from '../internal/utils';
-export function log(dataHost, dataMember, descriptor) {
+export function log(dataHost, dataMember, descriptor = undefined) {
     var _a;
-    if (descriptor === void 0) { descriptor = undefined; }
-    var facetClassAdmin = getFacetClassAdmin(dataHost.constructor);
+    const facetClassAdmin = getFacetClassAdmin(dataHost.constructor);
     facetClassAdmin.loggedMembers = (_a = facetClassAdmin.loggedMembers) !== null && _a !== void 0 ? _a : {};
     facetClassAdmin.loggedMembers[dataMember] = true;
     return descriptor;
 }
-export function data(dataHost, dataMember, descriptor) {
+export function data(dataHost, dataMember, descriptor = undefined) {
     var _a;
-    if (descriptor === void 0) { descriptor = undefined; }
-    var facetClassAdmin = getFacetClassAdmin(dataHost.constructor);
+    const facetClassAdmin = getFacetClassAdmin(dataHost.constructor);
     facetClassAdmin.dataMembers = (_a = facetClassAdmin.dataMembers) !== null && _a !== void 0 ? _a : {};
     facetClassAdmin.dataMembers[dataMember] = true;
     return log(dataHost, dataMember, descriptor);
@@ -23,5 +21,5 @@ export function getDataMemberNames(facet) {
     var _a;
     return Object.keys((_a = getFacetClassAdmin(facet.constructor).dataMembers) !== null && _a !== void 0 ? _a : {});
 }
-export var input = data;
-export var output = data;
+export const input = data;
+export const output = data;

package/lib/facet.js

@@ -5,13 +5,13 @@ export function facetClassName(facetClass) {
 export function getf(facetClass, ctr) {
     var _a;
     if (!ctr)
-        return function (ctr) { return getf(facetClass, ctr); };
-    var facet = typeof facetClass === 'string'
+        return (ctr) => getf(facetClass, ctr);
+    const facet = typeof facetClass === 'string'
         ? ctr[facetClass]
         : (_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 ".concat(facetName, " in container ").concat(getCtrAdmin(ctr).logName));
+        const facetName = facetClass === 'string' ? facetClass : facetClassName(facetClass);
+        console.error(`No facet ${facetName} in container ${getCtrAdmin(ctr).logName}`);
     }
     return facet;
 }

package/lib/install.js

@@ -1,5 +1,5 @@
 export function installPolicies(policies, ctr) {
-    policies.forEach(function (policy) {
+    policies.forEach((policy) => {
         policy(ctr);
     });
 }

package/lib/operation.js

@@ -7,78 +7,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) 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]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { log } from '../internal/logging';
 import { options } from '../internal/options';
 import { getFacetClassAdmin } from '../internal/utils';
 function _operation(target, propertyName, descriptor, punctualOptions) {
     var _a;
-    var f = descriptor.value;
-    var facetClassAdmin = getFacetClassAdmin(target.constructor);
+    const f = descriptor.value;
+    const facetClassAdmin = getFacetClassAdmin(target.constructor);
     facetClassAdmin.operationMemberNames =
         (_a = facetClassAdmin.operationMemberNames) !== null && _a !== void 0 ? _a : [];
     facetClassAdmin.operationMemberNames.push(propertyName);
     if (typeof descriptor.value === 'function') {
         descriptor.value = !!punctualOptions.async
-            ? function () {
+            ? function (...args) {
                 var _a;
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                return __awaiter(this, void 0, void 0, function () {
-                    var facet, isLogging, returnValue;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                facet = this;
-                                isLogging = options.logging && ((_a = punctualOptions.log) !== null && _a !== void 0 ? _a : true);
-                                isLogging && log(facet, propertyName, args, true);
-                                return [4 /*yield*/, f.bind(this).apply(void 0, args)];
-                            case 1:
-                                returnValue = _b.sent();
-                                isLogging && log(facet, propertyName, args, false);
-                                return [2 /*return*/, Promise.resolve(returnValue)];
-                        }
-                    });
+                return __awaiter(this, void 0, void 0, function* () {
+                    const facet = this;
+                    const isLogging = options.logging && ((_a = punctualOptions.log) !== null && _a !== void 0 ? _a : true);
+                    isLogging && log(facet, propertyName, args, true);
+                    const returnValue = yield f.bind(this)(...args);
+                    isLogging && log(facet, propertyName, args, false);
+                    return Promise.resolve(returnValue);
                 });
             }
-            : function () {
+            : function (...args) {
                 var _a;
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                var facet = this;
-                var isLogging = options.logging && ((_a = punctualOptions.log) !== null && _a !== void 0 ? _a : true);
+                const facet = this;
+                const isLogging = options.logging && ((_a = punctualOptions.log) !== null && _a !== void 0 ? _a : true);
                 isLogging && log(facet, propertyName, args, true);
-                var returnValue = f.bind(this).apply(void 0, args);
+                const returnValue = f.bind(this)(...args);
                 isLogging && log(facet, propertyName, args, false);
                 return returnValue;
             };
@@ -89,17 +46,13 @@ export function getOperationMemberNames(facet) {
     var _a;
     return (_a = getFacetClassAdmin(facet.constructor).operationMemberNames) !== null && _a !== void 0 ? _a : [];
 }
-export function operation() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
+export function operation(...args) {
     if (args.length === 1) {
-        var wrapped = function (target, propertyName, descriptor) {
+        const wrapped = (target, propertyName, descriptor) => {
             return _operation(target, propertyName, descriptor, args[0]);
         };
         return wrapped;
     }
-    var target = args[0], propertyName = args[1], descriptor = args[2];
+    const [target, propertyName, descriptor] = args;
     return _operation(target, propertyName, descriptor, {});
 }

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 (const key in mappings) {
+        if (mappings.hasOwnProperty(key)) {
+            const facet = target[key];
+            const propMappings = mappings[key];
+            if (facet && propMappings) {
+                for (const prop in propMappings) {
+                    if (propMappings.hasOwnProperty(prop)) {
+                        const 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

@@ -5,23 +5,23 @@ import { setCtr } from './ctr';
 import { facetClassName } from './facet';
 export function registerCtr(ctr, options) {
     var _a, _b, _c;
-    var ctrAdmin = getCtrAdmin(ctr);
+    const ctrAdmin = getCtrAdmin(ctr);
     ctrAdmin.logName = options.name;
     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.facets) !== null && _c !== void 0 ? _c : Object.getOwnPropertyNames(ctr)).forEach(function (facetName) {
-        var facet = ctr[facetName];
+    ((_c = options.facets) !== null && _c !== void 0 ? _c : Object.getOwnPropertyNames(ctr)).forEach((facetName) => {
+        const facet = ctr[facetName];
         setCtr(facet, ctr);
         ctrAdmin.facetMembers.push(facetName);
         if (!facet.constructor.className) {
-            console.error("Facet ".concat(facetName, " of container ").concat(ctrAdmin.logName, " ") +
-                "does not have a static className function");
+            console.error(`Facet ${facetName} of container ${ctrAdmin.logName} ` +
+                `does not have a static className function`);
         }
-        var className = facetClassName(facet.constructor);
-        getFacetAdmin(facet).logName = "".concat(ctrAdmin.logName, "/").concat(className);
+        const className = facetClassName(facet.constructor);
+        getFacetAdmin(facet).logName = `${ctrAdmin.logName}/${className}`;
         if (ctrAdmin.facetByFacetClassName[className] !== undefined) {
-            console.error("Two facets of same type ".concat(className, " in container ").concat(ctrAdmin.logName));
+            console.error(`Two facets of same type ${className} in container ${ctrAdmin.logName}`);
         }
         ctrAdmin.facetByFacetClassName[className] = facet;
     });

package/package.json

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