skandha 0.11.0 → 0.12.0

package/README.md

@@ -103,6 +103,22 @@ To allow SkandhaJS to log the container, you need to add the `className()` funct
 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
 
 Now that we have some idea of what a facet is, we will discuss containers.

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,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 (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.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.11.0",
+  "version": "0.12.0",
   "description": "Create data containers with modular behaviours",
   "main": "index.js",
   "repository": "https://github.com/mnieber/skandha.git",