skandha 0.11.0 → 0.12.1

package/README.md

@@ -2,22 +2,22 @@
 
 ## Introduction
 
-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.
+SkandhaJS is a library that provides data containers with generic (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)`.
+2. When the user clicks on a todo, the todo-list component calls `todoSelection.selectItem({id: 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:
+There are three ways in which facets help you to write reusable 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).
+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 the items that are being selected).
 
 ## Links
 
@@ -30,9 +30,10 @@ There are three ways in which facets help you to write generic code:
 ## Glossary (conceptual)
 
 - callback function: a function that is called by an operation to help implement that operation
-- callbackMap object: a collection of callback functions that is used by an operation.
+- callbacks object: a collection of callback functions that is used by an operation.
+- callbackMap: a dictionary that contains a callbacks object for every operation of a facet
 - 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.
+- facet: a class that implements a generic behaviour, such as selection.
 - operation: a member function of a facet that changes the data of that facet.
 
 ## Glossary (technical)
@@ -40,11 +41,11 @@ There are three ways in which facets help you to write generic code:
 - 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 used to map data between facets.
 - registerCtr: the function that tells SkandhaJS which containers and facets exist.
-- setCallbackMap: the function that installs the callbackMap objects that are used by a facet.
+- setCallbackMap: the function that installs the callbackMap for a facet.
 
 ## Example: a Selection facet
 
-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.
+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 selection state. In this example, we will show a simplified `Selection` facet class.
 
 ```
 // file: Selection.ts
@@ -76,7 +77,7 @@ 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 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.
+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 (this is explained later).
 
 ## Operations are decorated with `@operation`.
 
@@ -84,24 +85,38 @@ The `Selection` facet has a `selectItem()` operation that allows you to select f
 
 ## Operations are logged
 
-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.
+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 `@withCbs` decorator is used to enable callbacks in an operation.
 
 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)`, which internally calls the installed callback functions;
-- it restores the callbackMap object to its previous state. This ensures that nested calls work correctly.
+- Aspiration looks up the callbacks object (that was installed with `setCallbackMap()`) for the given operation;
+- It copies the operation arguments to the callbacks object, so that callback functions can access these arguments;
+- It calls `f(arguments)`, which internally will use the installed callback functions to do its job;
+- It restores the callbacks 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`.
+If the original function `f` wants to access the callbacks 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.
+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 with the `getf` function (e.g. `getf(Selection, ctr)` returns the selection facet in `ctr`).
+
+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. However, if you subclass the facet then you must add the `skandhaSymbol` member, as explained below.
+
+## Facets that use inheritance must have a static `skandhaSymbol` member
+
+Skandha will store class-level information about a facet class in the class itself. If you subclass a facet class then you must add a `skandhaSymbol` member so that Skandha will keep the information for the subclass separate from the information for the parent class:
+
+```
+// file: Selection.ts
+import { Selection } from 'skandha-facets';
+
+export class MySelection extends Selection {
+  static className = () => 'Selection';
+  static skandhaSymbol = Symbol('MySelection');
+}
+```
 
 ## Example: a container with Selection, Highlight and Filtering
 
@@ -188,7 +203,7 @@ We call `setCallbackMap()` to install a callbackMap object for each operation of
 
 ## The callback function can access the callbackMap object through `this`.
 
-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.
+When the clients calls `todosCtr.selection.selectItem()` and `select()` is called back, then all arguments of the `selectItem` 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.
 
 ## Callbacks can take care of side effects
 
@@ -200,7 +215,7 @@ In `createContainer.ts` we also have a `Filtering` facet that has an `apply(f)`
 
 ## 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(Selection, todosCtr)` returns `todosCtr.selection`. Second, it informs SkandhaJS how to log all facets of the container.
 
 ## Example: `mapDataToProps()` maps data onto each facet
 
@@ -269,7 +284,7 @@ If you want to render the facets with React then we need to let React know when
 ## Conclusion
 
 SkandhaJS introduces a lot of new patterns and ideas (that are of course not in fact new) to allow you to
-put reusable behaviours on top of your existing data-structures. The difference to a more standard approach
+put generic behaviours on top of your existing data-structures. The difference to a more standard approach
 can feel overwhelming, but it's important to point out the beneficial side effect of
 separating concerns in a clear and understandable way. We could add a `Editing` facet to our code and install
 a policy that says that changing the highlight disables editing. By using facets, we will not be tempted to put

package/index.d.ts

@@ -1,5 +1,6 @@
 export { getCtrState } from './internal/logging';
-export { decorateCb, getOptions, setOptions } from './internal/options';
+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';

package/index.js

@@ -1,5 +1,6 @@
 export { getCtrState } from './internal/logging';
-export { decorateCb, getOptions, setOptions } from './internal/options';
+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';

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,45 +18,43 @@ 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) });
         }, {});
     }
 }
 export function getCtrState(ctr) {
     var _a, _b;
-    return ((_b = (_a = getCtrAdmin(ctr)) === null || _a === void 0 ? void 0 : _a.ctrStateOverride) !== null && _b !== void 0 ? _b : defaultGetCtrState)(ctr);
+    return ((_b = (_a = getCtrAdmin(ctr)) === null || _a === void 0 ? void 0 : _a.getCtrState) !== null && _b !== void 0 ? _b : defaultGetCtrState)(ctr);
 }

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 (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]) {
-                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.js

@@ -7,14 +7,14 @@ export function mapDataToProp(facet, prop, getter) {
     });
 }
 export function mapDataToProps(target, mappings) {
-    for (var key in mappings) {
+    for (const key in mappings) {
         if (mappings.hasOwnProperty(key)) {
-            var facet = target[key];
-            var propMappings = mappings[key];
+            const facet = target[key];
+            const propMappings = mappings[key];
             if (facet && propMappings) {
-                for (var prop in propMappings) {
+                for (const prop in propMappings) {
                     if (propMappings.hasOwnProperty(prop)) {
-                        var getter = propMappings[prop];
+                        const getter = propMappings[prop];
                         if (getter) {
                             mapDataToProp(facet, prop, getter);
                         }

package/lib/registerCtr.d.ts

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

package/lib/registerCtr.js

@@ -3,29 +3,32 @@ import { options as skandhaOptions } from '../internal/options';
 import { getCtrAdmin, getFacetAdmin } from '../internal/utils';
 import { setCtr } from './ctr';
 import { facetClassName } from './facet';
-export function registerCtr(ctr, options) {
+export function registerCtr({ ctr, options, initCtr }) {
     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];
+    ctrAdmin.getCtrState = options.getCtrState;
+    ((_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;
     });
     if (skandhaOptions.logging) {
         console.log('%c     %s ctr initialized', 'color: gray', ctrAdmin.logName, getCtrState(ctr));
     }
+    if (initCtr) {
+        initCtr(ctr);
+    }
 }

package/package.json

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