Observable data. Reactive functions. Simple code. 

mweststrate

mobservable

* Computed value now yields consistent results when being inspected while in transaction

* Implemented #67: Reactive graph transformations. See: http://mweststrate.github.io/mobservable/refguide/create-transformer.html

* Implemented #59, `isObservable` and `observe` now support a property name as second param to observe individual values on maps and objects.

* Fixed #77: package consumers with --noImplicitAny should be able to build

* Introduced `mobservable.fastArray(array)`, in addition to `mobservable.observable(array)`. Which is much faster when adding items but doesn't support enumerability (`for (var idx in ar) ..` loops).

* Introduced `observableArray.peek()`, for fast access to the array values. Should be used read-only.

* Fixed 71: transactions should not influence running computations

* Fixed #65; illegal state exception when using a transaction inside a reactive function. Credits: @kmalakoff

* Fixed #61; if autorun was created during a transaction, postpone execution until the end of the transaction

* Fixed exception when autorunUntil finished immediately

* `toJSON` now serializes object trees with cycles as well. If you know the object tree is acyclic, pass in `false` as second parameter for a performance gain. 

* Introduced `mobservable.untracked(block)`

* Introduced `mobservable.autorunAsync(block, delay)`

Fixed inconsistency when using `transaction` and `@observer`, which sometimes caused stale values to be displayed.

Fix incompatibility issue with systemjs bundler (see PR 52)

* `map.size` is now a property instead of a function

* `map()` now accepts an array as entries to construct the new map

* introduced `isObservableObject`, `isObservableArray` and `isObservableMap`

* introduced `observe`, to observe observable arrays, objects and maps, similarly to Object.observe and Array.observe

* `extendObservable` now supports passing in multiple object properties

* added `mobservable.map()`, which creates a new map similarly to ES6 maps, yet observable. Until properly documentation, see the [MDN docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).

* Stricter argument checking for several api's.

* `reactiveComponent` -> `observer` (in `mobservable-react` package)

* dropped the `strict` and `logLevel` settings of mobservable. View functions are by default run in `strict` mode, `autorun` (formerly: `observe`) functions in `non-strict` mode (strict indicates that it is allowed to change other observable values during the computation of a view funtion). 

Use `extras.withStrict(boolean, block)` if you want to deviate from the default behavior.

* `observable` (formerly `makeReactive`) no longer accepts an options object. The modifiers `asReference`, `asStructure` and `asFlat` can be used instead.

* dropped the `default` export of observable

* Removed all earlier deprecated functions

* `mobservable` now ships with TypeScript 1.6 compliant module typings, no external typings file is required anymore.

* `mobservable-react` supports React Native as well through the import `"mobservable-react/native"`.

* `for (var key in observablearray)` now lists the correct keys

* `@observable` now works correct on classes that are transpiled by either TypeScript or Babel (Not all constructions where supported in Babel earlier)

export declare function checkIfStateIsBeingModifiedDuringView(context: IContextInfoStruct): void;

export declare function transaction<T>(action: () => T, thisArg?: any): T;

export declare function runAfterTransaction(action: () => void): void;

export declare function isInTransaction(): boolean;

export declare function untracked<T>(action: () => T): T;

    constructor(context: IContextInfoStruct);

    removeObserver(node: ViewNode): void;

    markReady(stateDidActuallyChange: boolean): void;

    notifyObservers(stateDidActuallyChange?: boolean): void;

export declare class ViewNode extends DataNode {

    notifyStateChange(observable: DataNode, stateDidActuallyChange: boolean): void;

    onceSleep(onSleep: (lastValue: any) => void): void;

export declare function stackDepth(): any;

export declare function isComputingView(): boolean;

import { IContextInfoStruct } from './interfaces';

 * https://github.com/mweststrate/mobservable

var __extends = (this && this.__extends) || function (d, b) {

    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];

    function __() { this.constructor = d; }

    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

    throw new Error("[mobservable] An incompatible version of mobservable is already loaded.");

function checkIfStateIsBeingModifiedDuringView(context) {

    if (core_1.getStrict() === true && isComputingView()) {

        var ts = global.__mobservableViewStack;

        throw new Error("[mobservable] It is not allowed to change the state during the computation of a reactive view. Should the data you are trying to modify actually be a view? \nUse 'mobservable.extras.withStrict(false, block)' to allow changes to be made inside views (unrecommended).\nView name: " + context.name + ".\nCurrent stack size is " + ts.length + ", active view: \"" + ts[ts.length - 1].toString() + "\".");

exports.checkIfStateIsBeingModifiedDuringView = checkIfStateIsBeingModifiedDuringView;

            var values = changedValues.splice(0);

            for (var i = 0, l = values.length; i < l; i++)

                values[i].markReady(true);

            var actions = afterTransactionItems.splice(0);

            for (var i = 0, l = actions.length; i < l; i++)

        afterTransactionItems.push(action);

exports.runAfterTransaction = runAfterTransaction;

exports.isInTransaction = isInTransaction;

        var dnode = new ViewNode({ object: null, name: "untracked" });

        global.__mobservableViewStack.push(dnode);

        global.__mobservableViewStack.pop();

    NodeState[NodeState["STALE"] = 0] = "STALE";

    NodeState[NodeState["PENDING"] = 1] = "PENDING";

    NodeState[NodeState["READY"] = 2] = "READY";

})(exports.NodeState || (exports.NodeState = {}));

            context = { name: undefined, object: undefined };

            context.name = "[m#" + this.id + "]";

    DataNode.prototype.setRefCount = function (delta) {

        this.externalRefenceCount += delta;

    DataNode.prototype.addObserver = function (node) {

        this.observers[this.observers.length] = node;

    DataNode.prototype.removeObserver = function (node) {

        var obs = this.observers, idx = obs.indexOf(node);

    DataNode.prototype.markStale = function () {

            extras_1.reportTransition(this, "STALE");

    DataNode.prototype.markReady = function (stateDidActuallyChange) {

                throw new Error("[mobservable] Illegal state; only data values can be readied while in transaction. Please file a bug with stacktrace.");

            extras_1.reportTransition(this, "READY", true, this["_value"]);

        this.notifyObservers(stateDidActuallyChange);

    DataNode.prototype.notifyObservers = function (stateDidActuallyChange) {

        if (stateDidActuallyChange === void 0) { stateDidActuallyChange = false; }

        for (var l = os.length, i = 0; i < l; i++)

            os[i].notifyStateChange(this, stateDidActuallyChange);

    DataNode.prototype.notifyObserved = function () {

        var ts = global.__mobservableViewStack, l = ts.length;

            var deps = ts[l - 1].observing, depslength = deps.length;

            if (deps[depslength - 1] !== this && deps[depslength - 2] !== this)

    DataNode.prototype.dispose = function () {

            throw new Error("[mobservable] Cannot dispose DNode; it is still being observed");

    DataNode.prototype.toString = function () {

        return "DNode[" + this.context.name + ", state: " + this.state + ", observers: " + this.observers.length + "]";

    ViewNode.prototype.setRefCount = function (delta) {

        var rc = this.externalRefenceCount += delta;

var simpleeventemitter_1 = require('./simpleeventemitter');

        throw new Error("[mobservable.view '" + name + "'] View functions do not accept new values");

exports.throwingViewSetter = throwingViewSetter;

var ObservableView = (function (_super) {

    function ObservableView(func, scope, context, compareStructural) {

        this.compareStructural = compareStructural;

        this.changeEvent = new simpleeventemitter_1.default();

    ObservableView.prototype.get = function () {

            throw new Error("[mobservable.view '" + this.context.name + "'] Cycle detected");

        if (this.state === dnode_1.NodeState.STALE && dnode_1.isInTransaction()) {

            return this.func.call(this.scope);

            if (dnode_1.isComputingView()) {

    ObservableView.prototype.set = function (x) {

        throwingViewSetter(this.context.name)();

    ObservableView.prototype.compute = function () {

        var newValue = this.func.call(this.scope);

        var changed = this.compareStructural ? !utils_1.deepEquals(newValue, this._value) : newValue !== this._value;

            this.changeEvent.emit(newValue, oldValue);

    ObservableView.prototype.observe = function (listener, fireImmediately) {

        if (fireImmediately === void 0) { fireImmediately = false; }

            listener(this.get(), undefined);

        var disposer = this.changeEvent.on(listener);

        return utils_1.once(function () {

    ObservableView.prototype.toString = function () {

        return "ComputedObservable[" + this.context.name + " (current value:'" + this._value + "')] " + this.func.toString();

//# sourceMappingURL=observableview.js.map

    "description": "Observable data. Reactive functions. Simple code.",

        "test": "npm run buildtest && tape test/*.js",

        "test-browser": "npm run buildtest && ( browserify test/*.js | tape-run )",

        "test-travis": "npm run clean && npm run test-browser && istanbul cover tape test/*.js",

        "coverage": "npm run buildtest && istanbul cover tape test/*.js && cat ./coverage/lcov.info|coveralls",

        "perf": "npm run build && time tape test/perf/*.js",

        "prepublish": "npm run clean && npm run build-dist",

        "clean-build": "npm run clean && npm run build",

        "build-dist": "npm run build && webpack && uglifyjs --in-source-map dist/mobservable.js.map -s dist/mobservable.js --source-map dist/mobservable.min.js.map -o dist/mobservable.min.js",

        "buildtest": "npm run build && npm run build-typescript-tests && npm run build-babel-tests",

        "build-typescript-tests": "tsc -m commonjs -t es5 --experimentalDecorators --noImplicitAny --outDir test test/typescript-tests.ts",

        "build-babel-tests": "babel --stage 0 test/babel/babel-tests.js -o test/babel-tests.js"

        "url": "https://github.com/mweststrate/mobservable.git"

        "url": "https://github.com/mweststrate/mobservable/issues"

    "homepage": "https://mweststrate.github.io/mobservable",

        "functional-reactive-programming"

		@@ -0,1 +1,5 @@
		# 1.2.1

		* Computed value now yields consistent results when being inspected while in transaction

		# 1.2.0
		@@ -2,0 +6,0 @@

		@@ -49,2 +49,6 @@ /**
		exports.runAfterTransaction = runAfterTransaction;
		function isInTransaction() {
		return inTransaction > 0;
		}
		exports.isInTransaction = isInTransaction;
		function untracked(action) {
		@@ -51,0 +55,0 @@ try {

		{
		"name": "mobservable",
		"version": "1.2.0",
		"version": "1.2.1",
		"description": "Observable data. Reactive functions. Simple code.",
		@@ -5,0 +5,0 @@ "main": "lib/index.js",

		@@ -33,2 +33,5 @@ /**
		throw new Error("[mobservable.view '" + this.context.name + "'] Cycle detected");
		if (this.state === dnode_1.NodeState.STALE && dnode_1.isInTransaction()) {
		return this.func.call(this.scope);
		}
		if (this.isSleeping) {
		@@ -35,0 +38,0 @@ if (dnode_1.isComputingView()) {

Improved metrics