mvvm-mobx 1.0.2 → 1.0.3

package/dist/commands/RelayCommand.js

@@ -1,31 +1,68 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelayCommand = void 0;
 const mobx_1 = require("mobx");
 const CounterFlag_1 = require("../core/CounterFlag");
-class RelayCommand {
-    constructor(executeFunc, canExecuteFunc) {
-        this.executeFunc = executeFunc;
-        this.canExecuteFunc = canExecuteFunc;
-        this.workingFlag = new CounterFlag_1.CounterFlag();
-        (0, mobx_1.makeObservable)(this);
-    }
-    canExecute(parameter) {
-        return this.canExecuteFunc?.(parameter) ?? true;
-    }
-    async execute(parameter) {
-        await this.workingFlag.using(async () => {
-            await this.executeFunc(parameter);
-        });
-    }
-}
+let RelayCommand = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _execute_decorators;
+    return _a = class RelayCommand {
+            constructor(executeFunc, canExecuteFunc) {
+                this.executeFunc = (__runInitializers(this, _instanceExtraInitializers), executeFunc);
+                this.canExecuteFunc = canExecuteFunc;
+                this.workingFlag = new CounterFlag_1.CounterFlag();
+                (0, mobx_1.makeObservable)(this);
+            }
+            canExecute(parameter) {
+                return this.canExecuteFunc?.(parameter) ?? true;
+            }
+            async execute(parameter) {
+                await this.workingFlag.using(async () => {
+                    await this.executeFunc(parameter);
+                });
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _execute_decorators = [mobx_1.action];
+            __esDecorate(_a, null, _execute_decorators, { kind: "method", name: "execute", static: false, private: false, access: { has: obj => "execute" in obj, get: obj => obj.execute }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 exports.RelayCommand = RelayCommand;
-__decorate([
-    mobx_1.action
-], RelayCommand.prototype, "execute", null);

package/dist/core/CounterFlag.d.ts

@@ -1,5 +1,5 @@
 export declare class CounterFlag {
-    private counter;
+    private accessor counter;
     constructor();
     /**
      * Activates the flag while executing the provided function.

package/dist/core/CounterFlag.js

@@ -1,9 +1,37 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
 var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
@@ -57,56 +85,82 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CounterFlag = void 0;
 const mobx_1 = require("mobx");
-class CounterFlag {
-    constructor() {
-        this.counter = 0;
-        (0, mobx_1.makeObservable)(this);
-    }
-    /**
-     * Activates the flag while executing the provided function.
-     * @param fn The function to execute while the flag is active.
-     */
-    async using(fn) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_1, this.increment(), false);
-            await fn();
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    }
-    /**
-     * Increments the counter and returns a disposable object that decreases the counter when disposed.
-     * @returns A disposable object that decreases the counter when disposed.
-     */
-    increment() {
-        this.counter++;
-        return {
-            [Symbol.dispose]: () => (0, mobx_1.runInAction)(() => this.counter--),
-        };
-    }
-    get isActive() {
-        return this.counter > 0;
-    }
-}
+let CounterFlag = (() => {
+    var _a, _CounterFlag_counter_accessor_storage;
+    let _instanceExtraInitializers = [];
+    let _counter_decorators;
+    let _counter_initializers = [];
+    let _counter_extraInitializers = [];
+    let _using_decorators;
+    let _increment_decorators;
+    let _get_isActive_decorators;
+    return _a = class CounterFlag {
+            get counter() { return __classPrivateFieldGet(this, _CounterFlag_counter_accessor_storage, "f"); }
+            set counter(value) { __classPrivateFieldSet(this, _CounterFlag_counter_accessor_storage, value, "f"); }
+            constructor() {
+                _CounterFlag_counter_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _counter_initializers, 0)));
+                __runInitializers(this, _counter_extraInitializers);
+                (0, mobx_1.makeObservable)(this);
+            }
+            /**
+             * Activates the flag while executing the provided function.
+             * @param fn The function to execute while the flag is active.
+             */
+            async using(fn) {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const _ = __addDisposableResource(env_1, this.increment(), false);
+                    await fn();
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
+            }
+            /**
+             * Increments the counter and returns a disposable object that decreases the counter when disposed.
+             * @returns A disposable object that decreases the counter when disposed.
+             */
+            increment() {
+                this.counter++;
+                return {
+                    [Symbol.dispose]: () => (0, mobx_1.runInAction)(() => this.counter--),
+                };
+            }
+            get isActive() {
+                return this.counter > 0;
+            }
+        },
+        _CounterFlag_counter_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _counter_decorators = [mobx_1.observable];
+            _using_decorators = [mobx_1.action];
+            _increment_decorators = [mobx_1.action];
+            _get_isActive_decorators = [mobx_1.computed];
+            __esDecorate(_a, null, _counter_decorators, { kind: "accessor", name: "counter", static: false, private: false, access: { has: obj => "counter" in obj, get: obj => obj.counter, set: (obj, value) => { obj.counter = value; } }, metadata: _metadata }, _counter_initializers, _counter_extraInitializers);
+            __esDecorate(_a, null, _using_decorators, { kind: "method", name: "using", static: false, private: false, access: { has: obj => "using" in obj, get: obj => obj.using }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _increment_decorators, { kind: "method", name: "increment", static: false, private: false, access: { has: obj => "increment" in obj, get: obj => obj.increment }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _get_isActive_decorators, { kind: "getter", name: "isActive", static: false, private: false, access: { has: obj => "isActive" in obj, get: obj => obj.isActive }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 exports.CounterFlag = CounterFlag;
-__decorate([
-    mobx_1.observable
-], CounterFlag.prototype, "counter", void 0);
-__decorate([
-    mobx_1.action
-], CounterFlag.prototype, "using", null);
-__decorate([
-    mobx_1.action
-], CounterFlag.prototype, "increment", null);
-__decorate([
-    mobx_1.computed
-], CounterFlag.prototype, "isActive", null);

package/dist/interaction/SingleConcurrentInteractionManager.d.ts

@@ -1,7 +1,7 @@
 import { InteractionManager } from "./InteractionManager";
 import { InteractionRequest } from "./InteractionRequest";
 export declare class SingleConcurrentInteractionManager implements InteractionManager {
-    interactionRequest: InteractionRequest | null;
+    accessor interactionRequest: InteractionRequest | null;
     private resolveFunc?;
     constructor();
     requestInteraction(interactionRequest: InteractionRequest): Promise<string | void>;

package/dist/interaction/SingleConcurrentInteractionManager.js

@@ -1,38 +1,92 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingleConcurrentInteractionManager = void 0;
 const mobx_1 = require("mobx");
-class SingleConcurrentInteractionManager {
-    constructor() {
-        this.interactionRequest = { title: '', content: '' };
-        (0, mobx_1.makeObservable)(this);
-        this.interactionRequest = null;
-    }
-    requestInteraction(interactionRequest) {
-        return new Promise((resolve) => {
-            this.interactionRequest = interactionRequest;
-            this.resolveFunc = resolve;
-        });
-    }
-    respond(interactionResponse) {
-        this.interactionRequest = null;
-        this.resolveFunc(interactionResponse);
-        this.resolveFunc = undefined;
-    }
-}
+let SingleConcurrentInteractionManager = (() => {
+    var _a, _SingleConcurrentInteractionManager_interactionRequest_accessor_storage;
+    let _instanceExtraInitializers = [];
+    let _interactionRequest_decorators;
+    let _interactionRequest_initializers = [];
+    let _interactionRequest_extraInitializers = [];
+    let _requestInteraction_decorators;
+    let _respond_decorators;
+    return _a = class SingleConcurrentInteractionManager {
+            get interactionRequest() { return __classPrivateFieldGet(this, _SingleConcurrentInteractionManager_interactionRequest_accessor_storage, "f"); }
+            set interactionRequest(value) { __classPrivateFieldSet(this, _SingleConcurrentInteractionManager_interactionRequest_accessor_storage, value, "f"); }
+            constructor() {
+                _SingleConcurrentInteractionManager_interactionRequest_accessor_storage.set(this, (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _interactionRequest_initializers, { title: '', content: '' })));
+                this.resolveFunc = __runInitializers(this, _interactionRequest_extraInitializers);
+                (0, mobx_1.makeObservable)(this);
+                this.interactionRequest = null;
+            }
+            requestInteraction(interactionRequest) {
+                return new Promise((resolve) => {
+                    this.interactionRequest = interactionRequest;
+                    this.resolveFunc = resolve;
+                });
+            }
+            respond(interactionResponse) {
+                this.interactionRequest = null;
+                this.resolveFunc(interactionResponse);
+                this.resolveFunc = undefined;
+            }
+        },
+        _SingleConcurrentInteractionManager_interactionRequest_accessor_storage = new WeakMap(),
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _interactionRequest_decorators = [mobx_1.observable];
+            _requestInteraction_decorators = [mobx_1.action];
+            _respond_decorators = [mobx_1.action];
+            __esDecorate(_a, null, _interactionRequest_decorators, { kind: "accessor", name: "interactionRequest", static: false, private: false, access: { has: obj => "interactionRequest" in obj, get: obj => obj.interactionRequest, set: (obj, value) => { obj.interactionRequest = value; } }, metadata: _metadata }, _interactionRequest_initializers, _interactionRequest_extraInitializers);
+            __esDecorate(_a, null, _requestInteraction_decorators, { kind: "method", name: "requestInteraction", static: false, private: false, access: { has: obj => "requestInteraction" in obj, get: obj => obj.requestInteraction }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _respond_decorators, { kind: "method", name: "respond", static: false, private: false, access: { has: obj => "respond" in obj, get: obj => obj.respond }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 exports.SingleConcurrentInteractionManager = SingleConcurrentInteractionManager;
-__decorate([
-    mobx_1.observable
-], SingleConcurrentInteractionManager.prototype, "interactionRequest", void 0);
-__decorate([
-    mobx_1.action
-], SingleConcurrentInteractionManager.prototype, "requestInteraction", null);
-__decorate([
-    mobx_1.action
-], SingleConcurrentInteractionManager.prototype, "respond", null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvvm-mobx",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MVVM pattern implementation with MobX for reactive state management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",