mobx-keystone 1.20.0 → 1.22.0

package/dist/types/actionMiddlewares/undoMiddleware.d.ts

@@ -74,7 +74,7 @@ export interface UndoEventGroup {
      */
     readonly events: ReadonlyArray<UndoEventWithoutAttachedState>;
 }
-declare const UndoStore_base: import('../model/Model')._Model<unknown, {
+declare const UndoStore_base: import('..')._Model<unknown, {
     undoEvents: import('..').OptionalModelProp<UndoEvent[]> & {
         $storedValueType: UndoEvent[];
         $storedCreationValueType: UndoEvent[] | null | undefined;

package/dist/types/modelShared/prop.d.ts

@@ -22,6 +22,7 @@ export interface ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TT
     $toSnapshotOverride: TToSnapshotOverride;
     _defaultFn: (() => TPropValue) | typeof noDefaultValue;
     _defaultValue: TPropValue | typeof noDefaultValue;
+    _defaultValueIsTransformed: boolean;
     _typeChecker: AnyStandardType | undefined;
     _setter: SetterMode;
     _setterValueTransform: ((value: unknown) => unknown) | undefined;
@@ -241,4 +242,8 @@ export declare function prop<TValue>(): MaybeOptionalModelProp<TValue>;
  * @ignore
  */
 export declare function getModelPropDefaultValue(propData: AnyModelProp): unknown | typeof noDefaultValue;
+/**
+ * @ignore
+ */
+export declare function getModelPropStoredDefaultValue(propData: AnyModelProp, model: object, propName: string): unknown | typeof noDefaultValue;
 export {};

package/dist/types/redux/connectReduxDevTools.d.ts

@@ -1,11 +1,24 @@
+export interface ConnectReduxDevToolsOptions {
+    /**
+     * If it should show the arguments near the action name.
+     *
+     * @default true
+     */
+    logArgsNearName?: boolean;
+    /**
+     * If it should log child actions when they run inside another action tracked
+     * by the same target tree.
+     *
+     * @default true
+     */
+    logChildActions?: boolean;
+}
 /**
  * Connects a tree node to a redux dev tools instance.
  *
  * @param remotedevPackage The remotedev package (usually the result of `require("remoteDev")`) (https://www.npmjs.com/package/remotedev).
  * @param remotedevConnection The result of a connect method from the remotedev package (usually the result of `remoteDev.connectViaExtension(...)`).
  * @param target Object to use as root.
- * @param [options] Optional options object. `logArgsNearName` if it should show the arguments near the action name (default is `true`).
+ * @param [options] Optional options object.
  */
-export declare function connectReduxDevTools(remotedevPackage: any, remotedevConnection: any, target: object, options?: {
-    logArgsNearName?: boolean;
-}): void;
+export declare function connectReduxDevTools(remotedevPackage: any, remotedevConnection: any, target: object, options?: ConnectReduxDevToolsOptions): void;

package/dist/types/ref/Ref.d.ts

@@ -1,5 +1,5 @@
 import { ModelClass } from '../modelShared/BaseModelShared';
-declare const Ref_base: import('../model/Model')._Model<unknown, {
+declare const Ref_base: import('..')._Model<unknown, {
     /**
      * Reference id.
      */

package/dist/types/treeUtils/sandbox.d.ts

@@ -24,7 +24,6 @@ export type WithSandboxCallback<T extends readonly [object, ...object[]], R> = (
  * original subtree and apply them to the original subtree or reject them.
  */
 export declare class SandboxManager {
-    private readonly subtreeRoot;
     /**
      * The sandbox copy of the original subtree.
      */
@@ -47,6 +46,7 @@ export declare class SandboxManager {
      * Whether changes made in the sandbox are currently being committed to the original subtree.
      */
     private isCommitting;
+    private readonly subtreeRoot;
     /**
      * Creates an instance of `SandboxManager`.
      * Do not use directly, use `sandbox` instead.

package/dist/types/types/TypeChecker.d.ts

@@ -3,7 +3,7 @@ import { AnyStandardType } from './schemas';
  * Type info base class.
  */
 export declare class TypeInfo {
-    readonly thisType: AnyStandardType;
     readonly kind: string;
+    readonly thisType: AnyStandardType;
     constructor(thisType: AnyStandardType);
 }

package/dist/types/types/arrayBased/typesArray.d.ts

@@ -17,8 +17,8 @@ export declare function typesArray<T extends AnyType>(itemType: T): ArrayType<T[
  * `types.array` type info.
  */
 export declare class ArrayTypeInfo extends TypeInfo {
-    readonly itemType: AnyStandardType;
     readonly kind = "array";
+    readonly itemType: AnyStandardType;
     get itemTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, itemType: AnyStandardType);
 }

package/dist/types/types/arrayBased/typesTuple.d.ts

@@ -17,8 +17,8 @@ export declare function typesTuple<T extends AnyType[]>(...itemTypes: T): ArrayT
  * `types.tuple` type info.
  */
 export declare class TupleTypeInfo extends TypeInfo {
-    readonly itemTypes: ReadonlyArray<AnyStandardType>;
     readonly kind = "tuple";
+    readonly itemTypes: ReadonlyArray<AnyStandardType>;
     private _itemTypeInfos;
     get itemTypeInfos(): ReadonlyArray<TypeInfo>;
     constructor(thisType: AnyStandardType, itemTypes: ReadonlyArray<AnyStandardType>);

package/dist/types/types/objectBased/typesArraySet.d.ts

@@ -18,8 +18,8 @@ export declare function typesArraySet<T extends AnyType>(valueType: T): ModelTyp
  * `types.arraySet` type info.
  */
 export declare class ArraySetTypeInfo extends TypeInfo {
-    readonly valueType: AnyStandardType;
     readonly kind = "arraySet";
+    readonly valueType: AnyStandardType;
     get valueTypeInfo(): TypeInfo;
     constructor(originalType: AnyStandardType, valueType: AnyStandardType);
 }

package/dist/types/types/objectBased/typesDataModelData.d.ts

@@ -35,8 +35,8 @@ export interface DataModelDataTypeInfoProps {
  * `types.dataModelData` type info.
  */
 export declare class DataModelDataTypeInfo extends TypeInfo {
-    readonly modelClass: ModelClass<AnyDataModel>;
     readonly kind = "dataModelData";
+    readonly modelClass: ModelClass<AnyDataModel>;
     private _props;
     get props(): DataModelDataTypeInfoProps;
     get modelType(): string;

package/dist/types/types/objectBased/typesModel.d.ts

@@ -34,8 +34,8 @@ export interface ModelTypeInfoProps {
  * `types.model` type info.
  */
 export declare class ModelTypeInfo extends TypeInfo {
-    readonly modelClass: ModelClass<AnyModel>;
     readonly kind = "model";
+    readonly modelClass: ModelClass<AnyModel>;
     private _props;
     get props(): ModelTypeInfoProps;
     get modelType(): string;

package/dist/types/types/objectBased/typesObject.d.ts

@@ -32,11 +32,11 @@ export interface ObjectTypeInfoProps {
  * `types.object` type info.
  */
 export declare class ObjectTypeInfo extends TypeInfo {
-    private _objTypeFn;
     readonly kind = "object";
+    private readonly _objTypeFn;
     private _props;
     get props(): ObjectTypeInfoProps;
-    constructor(thisType: AnyStandardType, _objTypeFn: ObjectTypeFunction);
+    constructor(thisType: AnyStandardType, objTypeFn: ObjectTypeFunction);
 }
 /**
  * A type that represents frozen data.
@@ -58,8 +58,8 @@ export declare function typesFrozen<T extends AnyType>(dataType: T): ModelType<F
  * `types.frozen` type info.
  */
 export declare class FrozenTypeInfo extends TypeInfo {
-    readonly dataType: AnyStandardType;
     readonly kind = "frozen";
+    readonly dataType: AnyStandardType;
     get dataTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, dataType: AnyStandardType);
 }

package/dist/types/types/objectBased/typesObjectMap.d.ts

@@ -18,8 +18,8 @@ export declare function typesObjectMap<T extends AnyType>(valueType: T): ModelTy
  * `types.objectMap` type info.
  */
 export declare class ObjectMapTypeInfo extends TypeInfo {
-    readonly valueType: AnyStandardType;
     readonly kind = "objectMap";
+    readonly valueType: AnyStandardType;
     get valueTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, valueType: AnyStandardType);
 }

package/dist/types/types/objectBased/typesRecord.d.ts

@@ -18,8 +18,8 @@ export declare function typesRecord<T extends AnyType>(valueType: T): RecordType
  * `types.record` type info.
  */
 export declare class RecordTypeInfo extends TypeInfo {
-    readonly valueType: AnyStandardType;
     readonly kind = "record";
+    readonly valueType: AnyStandardType;
     get valueTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, valueType: AnyStandardType);
 }

package/dist/types/types/primitiveBased/typesPrimitive.d.ts

@@ -19,8 +19,8 @@ export declare function typesLiteral<T extends PrimitiveValue>(literal: T): Iden
  * `types.literal` type info.
  */
 export declare class LiteralTypeInfo extends TypeInfo {
-    readonly literal: PrimitiveValue;
     readonly kind = "literal";
+    readonly literal: PrimitiveValue;
     constructor(thisType: AnyStandardType, literal: PrimitiveValue);
 }
 /**

package/dist/types/types/types.d.ts

@@ -19,8 +19,8 @@ import { TagTypeInfo, typesTag } from './utility/typesTag';
 import { typesUnchecked, UncheckedTypeInfo } from './utility/typesUnchecked';
 export { getTypeInfo } from './getTypeInfo';
 export { TypeInfo } from './TypeChecker';
-export type { ObjectTypeInfoProps, ModelTypeInfoProps };
-export { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, FrozenTypeInfo, ObjectMapTypeInfo, TagTypeInfo, RefinementTypeInfo, RecordTypeInfo, RefTypeInfo, UncheckedTypeInfo, SkipCheckTypeInfo, ObjectTypeInfo, ArraySetTypeInfo, ArrayTypeInfo, ModelTypeInfo, OrTypeInfo, TupleTypeInfo, CodecTypeInfo, };
+export type { ModelTypeInfoProps, ObjectTypeInfoProps };
+export { ArraySetTypeInfo, ArrayTypeInfo, BooleanTypeInfo, CodecTypeInfo, FrozenTypeInfo, LiteralTypeInfo, ModelTypeInfo, NumberTypeInfo, ObjectMapTypeInfo, ObjectTypeInfo, OrTypeInfo, RecordTypeInfo, RefinementTypeInfo, RefTypeInfo, SkipCheckTypeInfo, StringTypeInfo, TagTypeInfo, TupleTypeInfo, UncheckedTypeInfo, };
 export declare const types: {
     literal: typeof typesLiteral;
     undefined: import('./schemas').IdentityType<undefined>;
@@ -66,7 +66,7 @@ export declare const types: {
     mapObject<T extends AnyType>(valueType: T): import('./schemas').RecordType<T>;
     mapFromObject<T extends AnyType>(valueType: T): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').RecordType<T>, Map<string, import('./schemas').TypeToData<T>>>;
     mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').ArrayType<import('./schemas').ArrayType<[TKeyType, TValueType]>[]>, Map<import('./schemas').TypeToData<TKeyType>, import('./schemas').TypeToData<TValueType>>>;
-    setFromArray<T extends AnyType>(valueType: T): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').ArrayType<T[]>, Set<import('./schemas').TypeToData<T>> | import('mobx/dist/internal').ObservableSet<import('./schemas').TypeToData<T>>>;
+    setFromArray<T extends AnyType>(valueType: T): import('./utility/typesCodecCore').CodecFromEncoded<import('./schemas').ArrayType<T[]>, Set<import('./schemas').TypeToData<T>> | import('mobx').ObservableSet<import('./schemas').TypeToData<T>>>;
     /**
      * @deprecated Prefer `types.dateAsIsoString` instead.
      */

package/dist/types/types/utility/typesCodec.d.ts

@@ -4,9 +4,4 @@ import { createCodecPropTransform, resolveCodecSupport, resolveStoredType, resol
 import { typesDateAsIsoString, typesDateAsTimestamp } from './typesDate';
 import { typesMapFromArray, typesMapFromObject } from './typesMap';
 import { typesSetFromArray } from './typesSet';
-export { CodecTypeInfo, typesCodec };
-export { createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker, };
-export { typesBigInt };
-export { typesDateAsIsoString, typesDateAsTimestamp };
-export { typesMapFromArray, typesMapFromObject };
-export { typesSetFromArray };
+export { CodecTypeInfo, createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker, typesBigInt, typesCodec, typesDateAsIsoString, typesDateAsTimestamp, typesMapFromArray, typesMapFromObject, typesSetFromArray, };

package/dist/types/types/utility/typesCodecCore.d.ts

@@ -34,9 +34,9 @@ export declare const identityRuntimeAdapter: RuntimeAdapter<any, any>;
  * `types.codec` type info.
  */
 export declare class CodecTypeInfo extends TypeInfo {
+    readonly kind = "codec";
     readonly typeName: string;
     readonly encodedType: AnyStandardType;
-    readonly kind = "codec";
     get encodedTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, typeName: string, encodedType: AnyStandardType);
 }

package/dist/types/types/utility/typesOr.d.ts

@@ -28,9 +28,9 @@ export declare function typesOr<T extends AnyType[]>(...orTypes: T): T[number];
  * `types.or` type info.
  */
 export declare class OrTypeInfo extends TypeInfo {
+    readonly kind = "or";
     readonly orTypes: ReadonlyArray<AnyStandardType>;
     readonly dispatcher: ((sn: any) => AnyType) | undefined;
-    readonly kind = "or";
     private _orTypeInfos;
     get orTypeInfos(): ReadonlyArray<TypeInfo>;
     constructor(thisType: AnyStandardType, orTypes: ReadonlyArray<AnyStandardType>, dispatcher: ((sn: any) => AnyType) | undefined);

package/dist/types/types/utility/typesRefinement.d.ts

@@ -41,10 +41,10 @@ export declare function typesRefinement<T extends AnyType>(baseType: T, checkFn:
  * `types.refinement` type info.
  */
 export declare class RefinementTypeInfo extends TypeInfo {
+    readonly kind = "refinement";
     readonly baseType: AnyStandardType;
     readonly checkFunction: (data: any) => TypeCheckError | null | boolean;
     readonly typeName: string | undefined;
-    readonly kind = "refinement";
     get baseTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, baseType: AnyStandardType, checkFunction: (data: any) => TypeCheckError | null | boolean, typeName: string | undefined);
 }

package/dist/types/types/utility/typesSkipCheck.d.ts

@@ -27,8 +27,8 @@ export declare function typesSkipCheck<T extends AnyType>(baseType: T): T;
  * `types.skipCheck` type info.
  */
 export declare class SkipCheckTypeInfo extends TypeInfo {
-    readonly baseType: AnyStandardType;
     readonly kind = "skipCheck";
+    readonly baseType: AnyStandardType;
     get baseTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, baseType: AnyStandardType);
 }

package/dist/types/types/utility/typesTag.d.ts

@@ -36,10 +36,10 @@ export declare function typesTag<T extends AnyType, A>(baseType: T, tag: A, type
  * `types.tag` type info.
  */
 export declare class TagTypeInfo<A> extends TypeInfo {
+    readonly kind = "tag";
     readonly baseType: AnyStandardType;
     readonly tag: A;
     readonly typeName: string | undefined;
-    readonly kind = "tag";
     get baseTypeInfo(): TypeInfo;
     constructor(thisType: AnyStandardType, baseType: AnyStandardType, tag: A, typeName: string | undefined);
 }

package/dist/types/wrappers/ObjectMap.d.ts

@@ -14,6 +14,8 @@ export declare class ObjectMap<V> extends objectMapBase implements Map<string, V
     delete(key: string): boolean;
     forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void;
     get(key: string): V | undefined;
+    getOrInsert(key: string, defaultValue: V): V;
+    getOrInsertComputed(key: string, callback: (key: string) => V): V;
     has(key: string): boolean;
     set(key: string, value: V): this;
     get size(): number;

package/dist/types/wrappers/asMap.d.ts

@@ -1,20 +1,23 @@
 import { ObservableMap } from 'mobx';
+type Ts6MapExtras<K, V> = {
+    getOrInsert(key: K, defaultValue: V): V;
+    getOrInsertComputed(key: K, callback: (key: K) => V): V;
+};
+type ObservableMapWithDataObject<K, V, TDataObject> = ObservableMap<K, V> & Ts6MapExtras<K, V> & {
+    dataObject: TDataObject;
+};
 /**
  * Wraps an observable object or a tuple array to offer a map like interface.
  *
  * @param array Array.
  */
-export declare function asMap<K, V>(array: Array<[K, V]>): ObservableMap<K, V> & {
-    dataObject: Array<[K, V]>;
-};
+export declare function asMap<K, V>(array: Array<[K, V]>): ObservableMapWithDataObject<K, V, Array<[K, V]>>;
 /**
  * Wraps an observable object or a tuple array to offer a map like interface.
  *
  * @param object Object.
  */
-export declare function asMap<T>(object: Record<string, T>): ObservableMap<string, T> & {
-    dataObject: Record<string, T>;
-};
+export declare function asMap<T>(object: Record<string, T>): ObservableMapWithDataObject<string, T, Record<string, T>>;
 /**
  * Converts a map to an object. If the map is a collection wrapper it will return the backed object.
  *
@@ -27,3 +30,4 @@ export declare function mapToObject<T>(map: Pick<Map<string, T>, "forEach">): Re
  * @param map
  */
 export declare function mapToArray<K, V>(map: Pick<Map<K, V>, "forEach">): Array<[K, V]>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -66,23 +66,25 @@
     "mobx": "^6.0.0 || ^5.0.0 || ^4.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.29.0",
-    "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/plugin-proposal-decorators": "^7.29.0",
-    "@babel/preset-env": "^7.29.0",
-    "@babel/preset-typescript": "^7.28.5",
-    "@swc/core": "^1.15.17",
+    "@babel/core": "^8.0.1",
+    "@babel/plugin-proposal-decorators": "^8.0.2",
+    "@babel/plugin-transform-class-properties": "^8.0.1",
+    "@babel/plugin-transform-typescript": "^8.0.1",
+    "@babel/preset-env": "^8.0.2",
+    "@swc/core": "^1.15.43",
     "@types/babel__core": "^7.20.5",
-    "@types/node": "^25.3.2",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@types/node": "^26.0.1",
+    "@vitest/coverage-v8": "^4.1.9",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
     "shx": "^0.4.0",
     "spec.ts": "^1.1.3",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.28.17",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.0",
+    "vite-plugin-dts": "^5.0.3",
+    "vitest": "^4.1.9"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/action/applyAction.ts

@@ -1,114 +1,125 @@
-import { AnyFunction } from "../utils/AnyFunction"
-import { getDataModelAction } from "../dataModel/actions"
-import { detach } from "../parent/detach"
-import { resolvePathCheckingIds } from "../parent/path"
-import { Path } from "../parent/pathTypes"
-import { applyPatches } from "../patch/applyPatches"
-import { applySnapshot } from "../snapshot/applySnapshot"
-import { getStandaloneAction } from "../standardActions/actions"
-import { assertTweakedObject } from "../tweaker/core"
-import { failure } from "../utils"
-import { applyDelete } from "./applyDelete"
-import { applyMethodCall } from "./applyMethodCall"
-import { applySet } from "./applySet"
-import { BuiltInAction, isBuiltInAction } from "./builtInActions"
-import { isHookAction } from "./hookActions"
-
-/**
- * An action call.
- */
-export interface ActionCall {
-  /**
-   * Action name (name of the function).
-   */
-  readonly actionName: string
-
-  /**
-   * Action arguments.
-   */
-  readonly args: ReadonlyArray<any>
-
-  /**
-   * Path to the model where the action will be run, as an array of string | number.
-   */
-  readonly targetPath: Path
-
-  /**
-   * Ids of models along the path to the target, null if it is not a model.
-   */
-  readonly targetPathIds: ReadonlyArray<string | null>
-
-  /**
-   * Marks this action call as non-serialized.
-   */
-  readonly serialized?: boolean
-}
-
-const builtInActionToFunction = {
-  [BuiltInAction.ApplySnapshot]: applySnapshot,
-  [BuiltInAction.ApplyPatches]: applyPatches,
-  [BuiltInAction.Detach]: detach,
-  [BuiltInAction.ApplySet]: applySet,
-  [BuiltInAction.ApplyDelete]: applyDelete,
-  [BuiltInAction.ApplyMethodCall]: applyMethodCall,
-}
-
-/**
- * Applies (runs) an action over a target object.
- *
- * If you intend to apply serialized actions check one of the `applySerializedAction` methods instead.
- *
- * @param subtreeRoot Subtree root target object to run the action over.
- * @param call The action, usually as coming from `onActionMiddleware`.
- * @returns The return value of the action, if any.
- */
-export function applyAction<TRet = any>(subtreeRoot: object, call: ActionCall): TRet {
-  if (call.serialized) {
-    throw failure(
-      "cannot apply a serialized action call, use one of the 'applySerializedAction' methods instead"
-    )
-  }
-
-  assertTweakedObject(subtreeRoot, "subtreeRoot")
-
-  // resolve path while checking ids
-  const { value: current, resolved } = resolvePathCheckingIds(
-    subtreeRoot,
-    call.targetPath,
-    call.targetPathIds
-  )
-  if (!resolved) {
-    throw failure(
-      `object at path ${JSON.stringify(call.targetPath)} with ids ${JSON.stringify(
-        call.targetPathIds
-      )} could not be resolved`
-    )
-  }
-  assertTweakedObject(current, `resolved ${current}`, true)
-
-  if (isBuiltInAction(call.actionName)) {
-    const fnToCall = builtInActionToFunction[call.actionName] as AnyFunction | undefined
-    if (!fnToCall) {
-      throw failure(`assertion failed: unknown built-in action - ${call.actionName}`)
-    }
-
-    return fnToCall.apply(current, [current, ...call.args])
-  }
-
-  if (isHookAction(call.actionName)) {
-    throw failure(`calls to hooks (${call.actionName}) cannot be applied`)
-  }
-
-  const dataModelAction = getDataModelAction(call.actionName)
-  if (dataModelAction) {
-    const instance: any = new dataModelAction.modelClass(current)
-    return instance[dataModelAction.fnName](...call.args)
-  }
-
-  const standaloneAction = getStandaloneAction(call.actionName)
-  if (standaloneAction) {
-    return standaloneAction.apply(current, call.args as any)
-  }
-
-  return (current as any)[call.actionName].apply(current, call.args)
-}
+import { getDataModelAction } from "../dataModel/actions"
+import { detach } from "../parent/detach"
+import { resolvePathCheckingIds } from "../parent/path"
+import type { Path } from "../parent/pathTypes"
+import { applyPatches } from "../patch/applyPatches"
+import { applySnapshot } from "../snapshot/applySnapshot"
+import { getStandaloneAction } from "../standardActions/actions"
+import { assertTweakedObject } from "../tweaker/core"
+import { failure } from "../utils"
+import type { AnyFunction } from "../utils/AnyFunction"
+import { applyDelete } from "./applyDelete"
+import { applyMethodCall } from "./applyMethodCall"
+import { applySet } from "./applySet"
+import { BuiltInAction, isBuiltInAction } from "./builtInActions"
+import { isHookAction } from "./hookActions"
+import { isModelAction } from "./isModelAction"
+import { isModelFlow } from "./modelFlow"
+
+/**
+ * An action call.
+ */
+export interface ActionCall {
+  /**
+   * Action name (name of the function).
+   */
+  readonly actionName: string
+
+  /**
+   * Action arguments.
+   */
+  readonly args: ReadonlyArray<any>
+
+  /**
+   * Path to the model where the action will be run, as an array of string | number.
+   */
+  readonly targetPath: Path
+
+  /**
+   * Ids of models along the path to the target, null if it is not a model.
+   */
+  readonly targetPathIds: ReadonlyArray<string | null>
+
+  /**
+   * Marks this action call as non-serialized.
+   */
+  readonly serialized?: boolean
+}
+
+const builtInActionToFunction = {
+  [BuiltInAction.ApplySnapshot]: applySnapshot,
+  [BuiltInAction.ApplyPatches]: applyPatches,
+  [BuiltInAction.Detach]: detach,
+  [BuiltInAction.ApplySet]: applySet,
+  [BuiltInAction.ApplyDelete]: applyDelete,
+  [BuiltInAction.ApplyMethodCall]: applyMethodCall,
+}
+
+/**
+ * Applies (runs) an action over a target object.
+ *
+ * If you intend to apply serialized actions check one of the `applySerializedAction` methods instead.
+ *
+ * @param subtreeRoot Subtree root target object to run the action over.
+ * @param call The action, usually as coming from `onActionMiddleware`.
+ * @returns The return value of the action, if any.
+ */
+export function applyAction<TRet = any>(subtreeRoot: object, call: ActionCall): TRet {
+  if (call.serialized) {
+    throw failure(
+      "cannot apply a serialized action call, use one of the 'applySerializedAction' methods instead"
+    )
+  }
+
+  assertTweakedObject(subtreeRoot, "subtreeRoot")
+
+  // resolve path while checking ids
+  const { value: current, resolved } = resolvePathCheckingIds(
+    subtreeRoot,
+    call.targetPath,
+    call.targetPathIds
+  )
+  if (!resolved) {
+    throw failure(
+      `object at path ${JSON.stringify(call.targetPath)} with ids ${JSON.stringify(
+        call.targetPathIds
+      )} could not be resolved`
+    )
+  }
+  assertTweakedObject(current, `resolved ${current}`, true)
+
+  if (isBuiltInAction(call.actionName)) {
+    const fnToCall = builtInActionToFunction[call.actionName] as AnyFunction | undefined
+    if (!fnToCall) {
+      throw failure(`assertion failed: unknown built-in action - ${call.actionName}`)
+    }
+
+    return fnToCall.apply(current, [current, ...call.args])
+  }
+
+  if (isHookAction(call.actionName)) {
+    throw failure(`calls to hooks (${call.actionName}) cannot be applied`)
+  }
+
+  const dataModelAction = getDataModelAction(call.actionName)
+  if (dataModelAction) {
+    const instance: any = new dataModelAction.modelClass(current)
+    return instance[dataModelAction.fnName](...call.args)
+  }
+
+  const standaloneAction = getStandaloneAction(call.actionName)
+  if (standaloneAction) {
+    return standaloneAction.apply(current, call.args as any)
+  }
+
+  const actionFn = (current as any)[call.actionName]
+  if (typeof actionFn !== "function") {
+    throw failure(`action '${call.actionName}' could not be resolved to a function`)
+  }
+
+  if (!isModelAction(actionFn) && !isModelFlow(actionFn)) {
+    throw failure(`action '${call.actionName}' is not a model action`)
+  }
+
+  return actionFn.apply(current, call.args)
+}