@vue-modeler/model 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024-present Aleksandr Vladimirovich Bratko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# Introduction
+
+## What is @vue-modeler/model
+
+A state management library based on models for [VUE.js.](VUE.js.) The extremely simple API serves one purpose — creating models. It preserves types, supports OOP, DRY, and SOLID principles.
+
+Try it out! Level up your development process.
+
+---
+
+### Key Features
+- **No global state store**. No store means no problems. State is encapsulated within the model and is reactive. Outside the model, it's only accessible for reading and observation.
+- **Extremely simple API**: A model prototype is a standard class, actions are defined as standard methods with decorators. Create a model by calling a factory method — nothing more needed. Reactive properties and behavior are defined using the standard Vue API.
+- **Supports shared models**. A built-in model container ensures that a model remains in memory while being used. Unused models are automatically removed from the container.
+- **Follows DRY principle**. Actions have their own state. There's no need to write additional code to track action states. Focus instead on designing architecture and business logic.
+- **Embraces OOP**. Model prototypes are classes, supporting inheritance, encapsulation, polymorphism, and destructors.
+- **Complies with SOLID principles**. Encourages clean coding practices like composition of models, dependency injection via constructors, separation of interfaces, single responsibility, etc.
+- **Maintains type safety**. All code completion hints will work both inside and outside the context of the class.
+
+---
+
+### Simple Example
+%%Check how it's done here: [https://pinia.vuejs.org/introduction.html#Basic-example%%](https://pinia.vuejs.org/introduction.html#Basic-example%%)
+
+---
+
+### Goals of Creation
+
+#### **Eliminate boilerplate code in actions and reduce the codebase.**
+##### Problems:
+- Actions often come with repetitive code for tracking execution through extra variables such as `isLoading`, `isPending`. This code adds little value to business logic but inflates the codebase.
+- Cancelling or blocking an action can be challenging. Developers tend to reinvent the wheel, even though these operations are common patterns.
+- Exception handling introduces further complications—developers either forget about it or handle it inconsistently without clear guidelines.
+
+##### Solutions:
+- An action is represented as an object with reactive properties reflecting its execution status: `ready`, `pending`, `lock`, `abort`, `error`.
+- Block or cancel an action easily using the `lock` and `abort` methods.
+- Actions catch exceptions, create errors, save them as part of the state, and provide a unified interface for handling.
+
+Less code, fewer issues.
+
+#### **Use Classes and Interfaces**
+Both VUEX and Pinia employ custom approaches for managing stores and reusing common code. I wanted to use standard classes, interfaces, getters, and protected properties. That's why my models are built upon classes and support OOP patterns.
+
+#### **Reuse Business Logic Across Projects**
+Models are classes where dependencies are injected via constructors, so model files don't contain direct imports of external dependencies. Models can easily be extracted into separate modules and reused in other projects or with different UI libraries.
+
+---
+
+### Additional Benefits
+- **Layered project structure**:
+   - Application layer contains model definitions.
+   - Infrastructure layer includes request/response factories and API calls.
+   - UI layer handles templates, filters, and display logic.
+   - Configuration layer is the dependency container where developers establish relationships between models and other layers.
+- **Clear folder structure**. Each layer has its dedicated directory. Inside the application and infrastructure directories, subfolders are organized by domain areas.
+
+---
+
+This library promises to simplify state management in [Vue.js](Vue.js) applications while promoting clean, scalable, and maintainable code.

package/dist/decorator.d.ts

@@ -0,0 +1,3 @@
+export declare const action: MethodDecorator;
+
+export { }

package/dist/error.d.ts

@@ -0,0 +1,156 @@
+import { ComputedGetter } from 'vue';
+import { ComputedRef } from 'vue';
+import { DebuggerOptions } from 'vue';
+import { EffectScope } from 'vue';
+import { Ref } from 'vue';
+import { ShallowReactive } from 'vue';
+import { WatchStopHandle } from 'vue';
+
+declare class Action<Args extends any[] = unknown[]> {
+    protected model: ProtoModel;
+    protected actionFunction: OriginalMethodWrapper<Args>;
+    static readonly actionFlag: unique symbol;
+    static readonly possibleState: {
+        readonly pending: "pending";
+        readonly error: "error";
+        readonly lock: "lock";
+        readonly ready: "ready";
+        readonly abort: "abort";
+    };
+    static abortedByLock: symbol;
+    readonly name: string;
+    protected _state: ActionStateName;
+    protected _value: ActionValue;
+    protected _args: Args | null;
+    constructor(model: ProtoModel, // TODO: thing about this arg, it may be potential problem
+    actionFunction: OriginalMethodWrapper<Args>);
+    toString(): string;
+    get possibleStates(): ActionStateName[];
+    get state(): ActionStateName;
+    protected set state(newState: ActionStateName);
+    get abortController(): null | AbortController;
+    get args(): Args | never[];
+    get promise(): null | Promise<void>;
+    get error(): null | ActionError;
+    get abortReason(): unknown;
+    get isPending(): boolean;
+    get isError(): boolean;
+    get isReady(): boolean;
+    get isLock(): boolean;
+    get isAbort(): boolean;
+    is(...args: ActionStateName[]): boolean;
+    /**
+     * Put into action in PENDING state
+     */
+    exec(...args: Args): Promise<void>;
+    abort(reason?: unknown): Promise<void>;
+    lock(): Promise<void>;
+    unlock(): this;
+    protected setError(error: ActionError): this;
+    protected ready(): this;
+    resetError(): this;
+}
+
+/**
+ * IMPORTANT: this class looks like error,
+ * but it is an exception in the correct terminology "errors vs exceptions".
+ *
+ * In other words, this is a class of errors that must be handled
+ * and displayed to the user as messages in UI layer.
+ */
+export declare class ActionError extends Error {
+    protected actionName: string;
+    protected options: {
+        cause: Error;
+    };
+    constructor(actionName: string, options: {
+        cause: Error;
+    });
+    get cause(): Error;
+    throwCause(): void;
+    toString(): string;
+}
+
+/**
+ * IMPORTANT: this class is an error in the correct terminology "errors vs exceptions".
+ *
+ * In other words, this is a class of errors that must not be handled
+ * and should be visible in console.
+ *
+ * These are errors made in logic made during development
+ */
+export declare class ActionInternalError extends Error {
+    message: string;
+    protected options?: {
+        cause: Error;
+    } | undefined;
+    constructor(message: string, options?: {
+        cause: Error;
+    } | undefined);
+}
+
+declare interface ActionPendingValue {
+    promise: Promise<void>;
+    abortController: AbortController;
+}
+
+declare type ActionPublic = Omit<Action, 'call'>;
+
+declare type ActionStateName = keyof typeof Action.possibleState;
+
+export declare class ActionStatusConflictError extends ActionInternalError {
+    constructor(actionName: string, currentState: ActionStateName, newState: ActionStateName);
+}
+
+export declare class ActionUnexpectedAbortError extends ActionInternalError {
+    constructor(actionName: string, currentState: ActionStateName);
+}
+
+declare type ActionValue = ActionPendingValue | ActionError | null;
+
+declare type ModelConstructor = new (...args: any[]) => ProtoModel;
+
+declare type OriginalMethod<Args extends unknown[] = unknown[]> = (...args: Args) => void | Promise<void>;
+
+declare interface OriginalMethodWrapper<Args extends unknown[] = unknown[]> {
+    (...args: Args): void | Promise<void>;
+    [Action.actionFlag]: OriginalMethod;
+}
+
+declare abstract class ProtoModel {
+    protected _effectScope: EffectScope;
+    protected _actions: WeakMap<OriginalMethodWrapper<unknown[]>, ShallowReactive<ActionPublic>>;
+    protected _actionIds: WeakMap<ShallowReactive<ActionPublic>, number>;
+    protected _actionStates: Map<"error" | "abort" | "lock" | "pending" | "ready", Ref<number>>;
+    protected _actionsSize: number;
+    protected _unwatchers: Set<WatchStopHandle>;
+    get hasPendingActions(): boolean;
+    get hasActionWithError(): boolean;
+    protected watch(...args: unknown[]): WatchStopHandle;
+    protected computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
+    protected updateBit(number: number, bitPosition: number, bitValue: boolean): number;
+    protected createAction(actionFunction: OriginalMethodWrapper): ShallowReactive<ActionPublic>;
+    protected getActionStatesRef(stateName: ActionStateName): Ref<number>;
+    /**
+     * It is public method in context ProtoModel,
+     * but in Model<ProtoModel> context it is protected method
+     *
+     * @see type Model<T>
+     */
+    setActionState(action: Action): void;
+    isModelOf(typeModel: ModelConstructor): boolean;
+    /**
+     * This is an open method, but you won't be able to call it from outside the model
+     * because its argument is "OriginalMethodWrapper".
+     * "OriginalMethodWrapper" is not accessible from the outside,
+     * because the model is wrapped in a proxy and
+     * the "get" trap will always return an "Action" instead of "OriginalMethodWrapper".
+     *
+     * @param originalMethod - method to create action for
+     * @returns action
+     */
+    action(originalMethod: OriginalMethodWrapper): ShallowReactive<ActionPublic>;
+    destructor(): void;
+}
+
+export { }

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./proto-model-B4Pm8x5w.cjs"),u=(e,o,t)=>{if(typeof o!="string")throw new Error("Action name is not a string");if(typeof t.value!="function")throw new Error("Property value is not a function");if(!(e instanceof r.ProtoModel))throw new Error("Target is not instance of ProtoModel");const i=t.value,n={[o]:function(...s){return this.action(n[o]).exec(...s)}};n[o][r.Action.actionFlag]=i,t.value=n[o]};exports.action=u;

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+import { ComputedGetter } from 'vue';
+import { ComputedRef } from 'vue';
+import { DebuggerOptions } from 'vue';
+import { EffectScope } from 'vue';
+import { Provider } from '@vue-modeler/dc';
+import { ProviderOptions } from '@vue-modeler/dc';
+import { Ref } from 'vue';
+import { ShallowReactive } from 'vue';
+import { WatchStopHandle } from 'vue';
+
+declare class Action<Args extends any[] = unknown[]> {
+    protected model: ProtoModel;
+    protected actionFunction: OriginalMethodWrapper<Args>;
+    static readonly actionFlag: unique symbol;
+    static readonly possibleState: {
+        readonly pending: "pending";
+        readonly error: "error";
+        readonly lock: "lock";
+        readonly ready: "ready";
+        readonly abort: "abort";
+    };
+    static abortedByLock: symbol;
+    readonly name: string;
+    protected _state: ActionStateName;
+    protected _value: ActionValue;
+    protected _args: Args | null;
+    constructor(model: ProtoModel, // TODO: thing about this arg, it may be potential problem
+    actionFunction: OriginalMethodWrapper<Args>);
+    toString(): string;
+    get possibleStates(): ActionStateName[];
+    get state(): ActionStateName;
+    protected set state(newState: ActionStateName);
+    get abortController(): null | AbortController;
+    get args(): Args | never[];
+    get promise(): null | Promise<void>;
+    get error(): null | ActionError;
+    get abortReason(): unknown;
+    get isPending(): boolean;
+    get isError(): boolean;
+    get isReady(): boolean;
+    get isLock(): boolean;
+    get isAbort(): boolean;
+    is(...args: ActionStateName[]): boolean;
+    /**
+     * Put into action in PENDING state
+     */
+    exec(...args: Args): Promise<void>;
+    abort(reason?: unknown): Promise<void>;
+    lock(): Promise<void>;
+    unlock(): this;
+    protected setError(error: ActionError): this;
+    protected ready(): this;
+    resetError(): this;
+}
+
+/**
+ * IMPORTANT: this class looks like error,
+ * but it is an exception in the correct terminology "errors vs exceptions".
+ *
+ * In other words, this is a class of errors that must be handled
+ * and displayed to the user as messages in UI layer.
+ */
+declare class ActionError extends Error {
+    protected actionName: string;
+    protected options: {
+        cause: Error;
+    };
+    constructor(actionName: string, options: {
+        cause: Error;
+    });
+    get cause(): Error;
+    throwCause(): void;
+    toString(): string;
+}
+
+declare interface ActionPendingValue {
+    promise: Promise<void>;
+    abortController: AbortController;
+}
+
+export declare type ActionPublic = Omit<Action, 'call'>;
+
+export declare type ActionStateName = keyof typeof Action.possibleState;
+
+declare type ActionValue = ActionPendingValue | ActionError | null;
+
+export declare function createModel<Target extends ProtoModel>(protoModel: Target): Model<Target>;
+
+export declare type Model<T> = {
+    [K in keyof T]: T[K] extends ((...args: infer Args) => Promise<void>) ? Action<Args> : K extends ProtectedMethodInModel ? never : T[K];
+};
+
+export declare function model<T extends ProtoModel>(modelFactory: () => T, options?: ProviderOptions): Provider<Model<T>>;
+
+export declare interface ModelAdapterProxyConstructor {
+    new <Target extends ProtoModel>(target: Target, handler: ProxyHandler<Target>): Model<Target>;
+}
+
+export declare type ModelConstructor<T extends {
+    new (...args: any[]): any;
+}> = T extends {
+    new (...args: any[]): infer R;
+} ? R extends ProtoModel ? T : never : never;
+
+declare type ModelConstructor_2 = new (...args: any[]) => ProtoModel;
+
+export declare type OriginalMethod<Args extends unknown[] = unknown[]> = (...args: Args) => void | Promise<void>;
+
+export declare interface OriginalMethodWrapper<Args extends unknown[] = unknown[]> {
+    (...args: Args): void | Promise<void>;
+    [Action.actionFlag]: OriginalMethod;
+}
+
+export declare type ProtectedMethodInModel = 'action' | 'setActionState';
+
+export declare abstract class ProtoModel {
+    protected _effectScope: EffectScope;
+    protected _actions: WeakMap<OriginalMethodWrapper<unknown[]>, ShallowReactive<ActionPublic>>;
+    protected _actionIds: WeakMap<ShallowReactive<ActionPublic>, number>;
+    protected _actionStates: Map<"error" | "abort" | "lock" | "pending" | "ready", Ref<number>>;
+    protected _actionsSize: number;
+    protected _unwatchers: Set<WatchStopHandle>;
+    get hasPendingActions(): boolean;
+    get hasActionWithError(): boolean;
+    protected watch(...args: unknown[]): WatchStopHandle;
+    protected computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
+    protected updateBit(number: number, bitPosition: number, bitValue: boolean): number;
+    protected createAction(actionFunction: OriginalMethodWrapper): ShallowReactive<ActionPublic>;
+    protected getActionStatesRef(stateName: ActionStateName): Ref<number>;
+    /**
+     * It is public method in context ProtoModel,
+     * but in Model<ProtoModel> context it is protected method
+     *
+     * @see type Model<T>
+     */
+    setActionState(action: Action): void;
+    isModelOf(typeModel: ModelConstructor_2): boolean;
+    /**
+     * This is an open method, but you won't be able to call it from outside the model
+     * because its argument is "OriginalMethodWrapper".
+     * "OriginalMethodWrapper" is not accessible from the outside,
+     * because the model is wrapped in a proxy and
+     * the "get" trap will always return an "Action" instead of "OriginalMethodWrapper".
+     *
+     * @param originalMethod - method to create action for
+     * @returns action
+     */
+    action(originalMethod: OriginalMethodWrapper): ShallowReactive<ActionPublic>;
+    destructor(): void;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,21 @@
+import { P as s, A as f } from "./proto-model-BXAhWQOY.js";
+const u = (r, o, t) => {
+  if (typeof o != "string")
+    throw new Error("Action name is not a string");
+  if (typeof t.value != "function")
+    throw new Error("Property value is not a function");
+  if (!(r instanceof s))
+    throw new Error("Target is not instance of ProtoModel");
+  const i = t.value, n = {
+    // Action constructor checks that model has method with the same name.
+    // We can`t define anonymous function and change name because Function.name is readonly property.
+    // So we need to create stub object to save original method name
+    [o]: function(...e) {
+      return this.action(n[o]).exec(...e);
+    }
+  };
+  n[o][f.actionFlag] = i, t.value = n[o];
+};
+export {
+  u as action
+};

package/dist/index2.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("vue"),a=require("./proto-model-B4Pm8x5w.cjs");var S=Object.defineProperty,f=(t,e,r)=>e in t?S(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,s=(t,e,r)=>f(t,typeof e!="symbol"?e+"":e,r);function v(){var t;const e=(t=c.getCurrentInstance())==null?void 0:t.proxy;if(!e)throw new Error("Current instance is undefined");if(!e.$vueModelerDc)throw new Error("Dependency container undefined. Check plugin setup");return e.$vueModelerDc}function u(t,e={persistentInstance:!1}){const r=Symbol("provider"),i=()=>{const n=v(),o=n.get(r)||n.add(r,t);return e.persistentInstance||(o.subscribeOnParentScopeDispose(c.onScopeDispose),c.onScopeDispose(()=>{o.parentScopeCount>0||n.delete(r)})),o.instance};return i.__isProvider__=!0,Object.defineProperty(i,"asKey",{value:r,writable:!1}),i}class p{constructor(){s(this,"isServer",!0),s(this,"stateKey","__SSR_STATE__"),s(this,"serializers",new Set),s(this,"stateFromServer",{}),this.isServer=typeof window>"u",this.initStateFromServer()}initStateFromServer(){if(this.isServer||!globalThis.__INITIAL_STATE__)return;const e=typeof globalThis.__INITIAL_STATE__=="string"?JSON.parse(globalThis.__INITIAL_STATE__):globalThis.__INITIAL_STATE__;typeof e[this.stateKey]=="object"&&(this.stateFromServer=e[this.stateKey])}extractState(e){return this.stateFromServer[e]}addSerializer(e){return this.isServer&&this.serializers.add(e),e}removeSerializer(e){return this.isServer?this.serializers.delete(e):!1}serialize(){const e={};for(const r of this.serializers){const i=r();i.value!==void 0&&(e[i.extractionKey]=i.value)}return e}injectState(e){this.isServer&&(e[this.stateKey]=this.serialize())}}u(()=>new p);const _=Proxy;function d(t){if(!(t instanceof a.ProtoModel))throw new Error("ProtoModel instance is required");return new _(c.shallowReactive(t),{get(r,i,n){const o=Reflect.get(r,i,n),l=typeof o=="function";return l&&a.Action.actionFlag in o&&typeof o[a.Action.actionFlag]=="function"?r.action(o):l?o.bind(r):o}})}function h(t,e){return u(()=>d(t()),e)}exports.ProtoModel=a.ProtoModel;exports.createModel=d;exports.model=h;

package/dist/index2.js

@@ -0,0 +1,82 @@
+import { onScopeDispose as c, getCurrentInstance as d, shallowReactive as f } from "vue";
+import { P as S, A as l } from "./proto-model-BXAhWQOY.js";
+var _ = Object.defineProperty, h = (t, e, r) => e in t ? _(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, s = (t, e, r) => h(t, typeof e != "symbol" ? e + "" : e, r);
+function p() {
+  var t;
+  const e = (t = d()) == null ? void 0 : t.proxy;
+  if (!e)
+    throw new Error("Current instance is undefined");
+  if (!e.$vueModelerDc)
+    throw new Error("Dependency container undefined. Check plugin setup");
+  return e.$vueModelerDc;
+}
+function u(t, e = { persistentInstance: !1 }) {
+  const r = Symbol("provider"), n = () => {
+    const o = p(), i = o.get(r) || o.add(r, t);
+    return e.persistentInstance || (i.subscribeOnParentScopeDispose(c), c(() => {
+      i.parentScopeCount > 0 || o.delete(r);
+    })), i.instance;
+  };
+  return n.__isProvider__ = !0, Object.defineProperty(
+    n,
+    "asKey",
+    {
+      value: r,
+      writable: !1
+    }
+  ), n;
+}
+class v {
+  constructor() {
+    s(this, "isServer", !0), s(this, "stateKey", "__SSR_STATE__"), s(this, "serializers", /* @__PURE__ */ new Set()), s(this, "stateFromServer", {}), this.isServer = typeof window > "u", this.initStateFromServer();
+  }
+  initStateFromServer() {
+    if (this.isServer || !globalThis.__INITIAL_STATE__)
+      return;
+    const e = typeof globalThis.__INITIAL_STATE__ == "string" ? JSON.parse(globalThis.__INITIAL_STATE__) : globalThis.__INITIAL_STATE__;
+    typeof e[this.stateKey] == "object" && (this.stateFromServer = e[this.stateKey]);
+  }
+  extractState(e) {
+    return this.stateFromServer[e];
+  }
+  addSerializer(e) {
+    return this.isServer && this.serializers.add(e), e;
+  }
+  removeSerializer(e) {
+    return this.isServer ? this.serializers.delete(e) : !1;
+  }
+  serialize() {
+    const e = {};
+    for (const r of this.serializers) {
+      const n = r();
+      n.value !== void 0 && (e[n.extractionKey] = n.value);
+    }
+    return e;
+  }
+  injectState(e) {
+    this.isServer && (e[this.stateKey] = this.serialize());
+  }
+}
+u(() => new v());
+const y = Proxy;
+function I(t) {
+  if (!(t instanceof S))
+    throw new Error("ProtoModel instance is required");
+  return new y(
+    f(t),
+    {
+      get(r, n, o) {
+        const i = Reflect.get(r, n, o), a = typeof i == "function";
+        return a && l.actionFlag in i && typeof i[l.actionFlag] == "function" ? r.action(i) : a ? i.bind(r) : i;
+      }
+    }
+  );
+}
+function g(t, e) {
+  return u(() => I(t()), e);
+}
+export {
+  S as ProtoModel,
+  I as createModel,
+  g as model
+};

package/dist/index3.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class n extends Error{constructor(r,t){super(t.cause.message),this.actionName=r,this.options=t,this.name=this.constructor.name}get cause(){return this.options.cause}throwCause(){throw this.cause}toString(){return this.options.cause.message}}class s extends Error{constructor(r,t){super(r,t),this.message=r,this.options=t,this.name=this.constructor.name}}class c extends s{constructor(r,t,e){super(`Trying to update state of ${r} from ${t} to ${e}`),this.name=this.constructor.name}}class i extends s{constructor(r,t){super(`Unexpected AbortError for the action ${r} in state ${t}`),this.name=this.constructor.name}}exports.ActionError=n;exports.ActionInternalError=s;exports.ActionStatusConflictError=c;exports.ActionUnexpectedAbortError=i;

package/dist/index3.js

@@ -0,0 +1,35 @@
+class n extends Error {
+  constructor(r, t) {
+    super(t.cause.message), this.actionName = r, this.options = t, this.name = this.constructor.name;
+  }
+  get cause() {
+    return this.options.cause;
+  }
+  throwCause() {
+    throw this.cause;
+  }
+  toString() {
+    return this.options.cause.message;
+  }
+}
+class e extends Error {
+  constructor(r, t) {
+    super(r, t), this.message = r, this.options = t, this.name = this.constructor.name;
+  }
+}
+class c extends e {
+  constructor(r, t, o) {
+    super(`Trying to update state of ${r} from ${t} to ${o}`), this.name = this.constructor.name;
+  }
+}
+class a extends e {
+  constructor(r, t) {
+    super(`Unexpected AbortError for the action ${r} in state ${t}`), this.name = this.constructor.name;
+  }
+}
+export {
+  n as ActionError,
+  e as ActionInternalError,
+  c as ActionStatusConflictError,
+  a as ActionUnexpectedAbortError
+};

package/dist/proto-model-B4Pm8x5w.cjs

@@ -0,0 +1 @@
+"use strict";var p=Object.defineProperty;var S=(i,t,e)=>t in i?p(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e;var r=(i,t,e)=>S(i,typeof t!="symbol"?t+"":t,e);const l=require("vue"),a=require("./index3.cjs"),b=i=>i instanceof DOMException&&i.name==="AbortError"||typeof i=="object"&&i!==null&&"message"in i&&i.message==="canceled",s=class s{constructor(t,e){r(this,"name");r(this,"_state",s.possibleState.ready);r(this,"_value",null);r(this,"_args",null);this.model=t,this.actionFunction=e;const o=e.name;if(!(o in t&&typeof t[o]=="function"))throw new a.ActionInternalError(`Model does not contain method ${o}`);if(typeof e[s.actionFlag]!="function")throw new a.ActionInternalError(`Method ${o} is not action`);this.name=o}toString(){return this.name}get possibleStates(){return Object.values(s.possibleState)}get state(){return this._state}set state(t){this._state=t,this.model.setActionState(this)}get abortController(){return this.isPending?this._value.abortController:null}get args(){return this._args||[]}get promise(){return this.isPending?this._value.promise:null}get error(){return this.isError?this._value:null}get abortReason(){return this.isAbort?this._value.abortController.signal.reason:null}get isPending(){return this.state===s.possibleState.pending}get isError(){return this.state===s.possibleState.error}get isReady(){return this.state===s.possibleState.ready}get isLock(){return this.state===s.possibleState.lock}get isAbort(){return this.state===s.possibleState.abort}is(...t){return!!t.find(e=>this.state===e)}exec(...t){if(this.is(s.possibleState.lock,s.possibleState.pending))throw new a.ActionStatusConflictError(this.name,this.state,s.possibleState.pending);const e=[...t];let o=t.length&&t[t.length-1];o instanceof AbortController||(o=new AbortController,e.push(o)),this.state=s.possibleState.pending,this._args=t;const h=this.actionFunction[s.actionFlag].apply(this.model,e);if(!(h instanceof Promise))return this.state=s.possibleState.ready,Promise.resolve(h);const f=h.then(()=>{this.ready()}).catch(n=>{if(n instanceof a.ActionInternalError||n instanceof RangeError||n instanceof ReferenceError||n instanceof SyntaxError||n instanceof TypeError||n instanceof URIError||n instanceof EvalError)throw n;const d=b(n);if(d&&!this.is(s.possibleState.pending,s.possibleState.lock))throw new a.ActionUnexpectedAbortError(this.name,this.state);if(d&&this._value.abortController instanceof AbortController&&this._value.abortController.signal.reason===s.abortedByLock){this.state=s.possibleState.lock,this._value=null;return}if(d){this.state=s.possibleState.abort;return}this.setError(new a.ActionError(this.name,{cause:n}))});return this._value={promise:f,abortController:o},f}abort(t){return this.isPending?(this._value.abortController.abort(t),this._value.promise):Promise.resolve()}lock(){return this.isPending?this.abort(s.abortedByLock):(this.state=s.possibleState.lock,this._value=null,Promise.resolve())}unlock(){if(!this.isLock)throw new a.ActionStatusConflictError(this.name,this.state,s.possibleState.ready);return this.ready()}setError(t){if(!this.isPending)throw new a.ActionStatusConflictError(this.name,this.state,s.possibleState.error);return this.state=s.possibleState.error,this._value=t,this}ready(){return this.state=s.possibleState.ready,this}resetError(){if(!this.error)throw new a.ActionStatusConflictError(this.name,this.state,s.possibleState.ready);return this.ready()}};r(s,"actionFlag",Symbol("__action_original_method__")),r(s,"possibleState",{pending:"pending",error:"error",lock:"lock",ready:"ready",abort:"abort"}),r(s,"abortedByLock",Symbol("lock"));let c=s;class g{constructor(){r(this,"_effectScope",l.effectScope(!0));r(this,"_actions",new WeakMap);r(this,"_actionIds",new WeakMap);r(this,"_actionStates",new Map);r(this,"_actionsSize",0);r(this,"_unwatchers",new Set)}get hasPendingActions(){return!!this.getActionStatesRef(c.possibleState.pending).value}get hasActionWithError(){return!!this.getActionStatesRef(c.possibleState.error).value}watch(...t){const e=this._effectScope.run(()=>l.watch(...t));if(!e)throw new Error("watchStopHandler is undefined");return this._unwatchers.add(e),e}computed(t,e){return this._effectScope.run(()=>l.computed(t,e))}updateBit(t,e,o){const u=o?1:0,h=~(1<<e);return t&h|u<<e}createAction(t){const e=l.shallowReactive(new c(this,t));return this._actions.set(t,e),this._actionIds.set(e,++this._actionsSize),this.setActionState(e),e}getActionStatesRef(t){const e=this._actionStates.get(t)||l.ref(0);return this._actionStates.get(t)===void 0&&this._actionStates.set(t,e),e}setActionState(t){const e=this._actionIds.get(t);if(!e)throw new Error("Action not found");for(const o of t.possibleStates)o!==t.state&&(this.getActionStatesRef(o).value=this.updateBit(this.getActionStatesRef(o).value,e,!1));this.getActionStatesRef(t.state).value=this.updateBit(this.getActionStatesRef(t.state).value,e,!0)}isModelOf(t){return this instanceof t}action(t){return this._actions.get(t)||this.createAction(t)}destructor(){this._unwatchers.forEach(t=>{t()}),this._unwatchers=new Set,this._effectScope.stop()}}exports.Action=c;exports.ProtoModel=g;

package/dist/proto-model-BXAhWQOY.js

@@ -0,0 +1,233 @@
+var p = Object.defineProperty;
+var b = (r, t, e) => t in r ? p(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var i = (r, t, e) => b(r, typeof t != "symbol" ? t + "" : t, e);
+import { effectScope as S, watch as g, computed as w, shallowReactive as m, ref as A } from "vue";
+import { ActionInternalError as d, ActionStatusConflictError as c, ActionUnexpectedAbortError as v, ActionError as y } from "./index3.js";
+const k = (r) => r instanceof DOMException && r.name === "AbortError" || typeof r == "object" && r !== null && "message" in r && r.message === "canceled", s = class s {
+  constructor(t, e) {
+    i(this, "name");
+    i(this, "_state", s.possibleState.ready);
+    i(this, "_value", null);
+    i(this, "_args", null);
+    this.model = t, this.actionFunction = e;
+    const o = e.name;
+    if (!(o in t && typeof t[o] == "function"))
+      throw new d(`Model does not contain method ${o}`);
+    if (typeof e[s.actionFlag] != "function")
+      throw new d(`Method ${o} is not action`);
+    this.name = o;
+  }
+  toString() {
+    return this.name;
+  }
+  get possibleStates() {
+    return Object.values(s.possibleState);
+  }
+  get state() {
+    return this._state;
+  }
+  set state(t) {
+    this._state = t, this.model.setActionState(this);
+  }
+  get abortController() {
+    return this.isPending ? this._value.abortController : null;
+  }
+  // TODO: add tests
+  get args() {
+    return this._args || [];
+  }
+  get promise() {
+    return this.isPending ? this._value.promise : null;
+  }
+  get error() {
+    return this.isError ? this._value : null;
+  }
+  get abortReason() {
+    return this.isAbort ? this._value.abortController.signal.reason : null;
+  }
+  get isPending() {
+    return this.state === s.possibleState.pending;
+  }
+  get isError() {
+    return this.state === s.possibleState.error;
+  }
+  get isReady() {
+    return this.state === s.possibleState.ready;
+  }
+  get isLock() {
+    return this.state === s.possibleState.lock;
+  }
+  get isAbort() {
+    return this.state === s.possibleState.abort;
+  }
+  is(...t) {
+    return !!t.find((e) => this.state === e);
+  }
+  /**
+   * Put into action in PENDING state  
+   */
+  exec(...t) {
+    if (this.is(s.possibleState.lock, s.possibleState.pending))
+      throw new c(
+        this.name,
+        this.state,
+        s.possibleState.pending
+      );
+    const e = [...t];
+    let o = t.length && t[t.length - 1];
+    o instanceof AbortController || (o = new AbortController(), e.push(o)), this.state = s.possibleState.pending, this._args = t;
+    const a = this.actionFunction[s.actionFlag].apply(this.model, e);
+    if (!(a instanceof Promise))
+      return this.state = s.possibleState.ready, Promise.resolve(a);
+    const f = a.then(() => {
+      this.ready();
+    }).catch((n) => {
+      if (n instanceof d || n instanceof RangeError || n instanceof ReferenceError || n instanceof SyntaxError || n instanceof TypeError || n instanceof URIError || n instanceof EvalError)
+        throw n;
+      const u = k(n);
+      if (u && !this.is(s.possibleState.pending, s.possibleState.lock))
+        throw new v(this.name, this.state);
+      if (u && this._value.abortController instanceof AbortController && this._value.abortController.signal.reason === s.abortedByLock) {
+        this.state = s.possibleState.lock, this._value = null;
+        return;
+      }
+      if (u) {
+        this.state = s.possibleState.abort;
+        return;
+      }
+      this.setError(new y(this.name, { cause: n }));
+    });
+    return this._value = {
+      promise: f,
+      abortController: o
+    }, f;
+  }
+  // Returns same promise as exec method
+  // but in reject state
+  // So, any code awaiting promise from exec will be rejected
+  abort(t) {
+    return this.isPending ? (this._value.abortController.abort(t), this._value.promise) : Promise.resolve();
+  }
+  lock() {
+    return this.isPending ? this.abort(s.abortedByLock) : (this.state = s.possibleState.lock, this._value = null, Promise.resolve());
+  }
+  unlock() {
+    if (!this.isLock)
+      throw new c(
+        this.name,
+        this.state,
+        s.possibleState.ready
+      );
+    return this.ready();
+  }
+  setError(t) {
+    if (!this.isPending)
+      throw new c(
+        this.name,
+        this.state,
+        s.possibleState.error
+      );
+    return this.state = s.possibleState.error, this._value = t, this;
+  }
+  ready() {
+    return this.state = s.possibleState.ready, this;
+  }
+  resetError() {
+    if (!this.error)
+      throw new c(
+        this.name,
+        this.state,
+        s.possibleState.ready
+      );
+    return this.ready();
+  }
+};
+i(s, "actionFlag", Symbol("__action_original_method__")), i(s, "possibleState", {
+  pending: "pending",
+  error: "error",
+  lock: "lock",
+  ready: "ready",
+  abort: "abort"
+}), i(s, "abortedByLock", Symbol("lock"));
+let h = s;
+class E {
+  constructor() {
+    // each model has its own effect scope to avoid memory leaks
+    i(this, "_effectScope", S(!0));
+    // we use WeakMap to store actions as keys to avoid memory leaks
+    i(this, "_actions", /* @__PURE__ */ new WeakMap());
+    i(this, "_actionIds", /* @__PURE__ */ new WeakMap());
+    i(this, "_actionStates", /* @__PURE__ */ new Map());
+    // WeakMap doesn't have a size property, so we need to store the size of the map
+    i(this, "_actionsSize", 0);
+    // watchers are stored in a set to avoid memory leaks
+    i(this, "_unwatchers", /* @__PURE__ */ new Set());
+  }
+  get hasPendingActions() {
+    return !!this.getActionStatesRef(h.possibleState.pending).value;
+  }
+  get hasActionWithError() {
+    return !!this.getActionStatesRef(h.possibleState.error).value;
+  }
+  watch(...t) {
+    const e = this._effectScope.run(() => g(...t));
+    if (!e)
+      throw new Error("watchStopHandler is undefined");
+    return this._unwatchers.add(e), e;
+  }
+  computed(t, e) {
+    return this._effectScope.run(() => w(t, e));
+  }
+  // @see https://github.com/trekhleb/javascript-algorithms/blob/master/src/algorithms/math/bits/updateBit.js
+  updateBit(t, e, o) {
+    const l = o ? 1 : 0, a = ~(1 << e);
+    return t & a | l << e;
+  }
+  createAction(t) {
+    const e = m(new h(this, t));
+    return this._actions.set(t, e), this._actionIds.set(e, ++this._actionsSize), this.setActionState(e), e;
+  }
+  getActionStatesRef(t) {
+    const e = this._actionStates.get(t) || A(0);
+    return this._actionStates.get(t) === void 0 && this._actionStates.set(t, e), e;
+  }
+  /**
+   * It is public method in context ProtoModel,
+   * but in Model<ProtoModel> context it is protected method
+   * 
+   * @see type Model<T>
+   */
+  setActionState(t) {
+    const e = this._actionIds.get(t);
+    if (!e)
+      throw new Error("Action not found");
+    for (const o of t.possibleStates)
+      o !== t.state && (this.getActionStatesRef(o).value = this.updateBit(this.getActionStatesRef(o).value, e, !1));
+    this.getActionStatesRef(t.state).value = this.updateBit(this.getActionStatesRef(t.state).value, e, !0);
+  }
+  isModelOf(t) {
+    return this instanceof t;
+  }
+  /**
+  * This is an open method, but you won't be able to call it from outside the model
+  * because its argument is "OriginalMethodWrapper".
+  * "OriginalMethodWrapper" is not accessible from the outside,
+  * because the model is wrapped in a proxy and
+  * the "get" trap will always return an "Action" instead of "OriginalMethodWrapper".
+  * 
+  * @param originalMethod - method to create action for
+  * @returns action
+  */
+  action(t) {
+    return this._actions.get(t) || this.createAction(t);
+  }
+  destructor() {
+    this._unwatchers.forEach((t) => {
+      t();
+    }), this._unwatchers = /* @__PURE__ */ new Set(), this._effectScope.stop();
+  }
+}
+export {
+  h as A,
+  E as P
+};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "type": "module",
+  "name": "@vue-modeler/model",
+  "version": "1.0.0",
+  "description": "A state management library based on models for Vue.js",
+  "author": "abratko",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs"
+    },
+    "./decorator": {
+      "import": "./dist/decorator.js",
+      "require": "./dist/decorator.umd.cjs"
+    },
+    "./error": {
+      "import": "./dist/error.js",
+      "require": "./dist/error.umd.cjs"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.11.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/eslint__js": "^8.42.3",
+    "@types/node": "^22.7.2",
+    "@vitest/coverage-v8": "2.1.3",
+    "@vue/test-utils": "^1.3.6",
+    "eslint": "^9.11.1",
+    "jsdom": "^25.0.1",
+    "semantic-release": "^24.2.0",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.7.0",
+    "vite": "^5.4.8",
+    "vite-plugin-dts": "^4.2.2",
+    "vitest": "^2.1.3"
+  },
+  "peerDependencies": {
+    "@vue-modeler/dc": "^2.1.0-beta",
+    "vue": "^2.7"
+  },
+  "scripts": {
+    "build": "tsc && vite build",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "semantic-release": "semantic-release"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vue-modeler/modeler.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vue-modeler/modeler/issues"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "keywords": [
+    "vue",
+    "model",
+    "state",
+    "manager"
+  ],
+  "homepage": "https://github.com/vue-modeler/modeler#readme",
+  "dependencies": {
+    "eslint-scope": "^8.2.0",
+    "eslint-visitor-keys": "^4.2.0",
+    "prettier": "^2.8.8",
+    "vue": "^2.7.16"
+  }
+}