mobx-keystone 2.3.0 → 2.3.1

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

@@ -1,33 +1,33 @@
-import { ArrayTypeInfo, typesArray } from './arrayBased/typesArray';
-import { TupleTypeInfo, typesTuple } from './arrayBased/typesTuple';
-import { ArraySetTypeInfo, typesArraySet } from './objectBased/typesArraySet';
-import { typesDataModelData } from './objectBased/typesDataModelData';
-import { ModelTypeInfo, ModelTypeInfoProps, typesModel } from './objectBased/typesModel';
-import { FrozenTypeInfo, ObjectTypeInfo, ObjectTypeInfoProps, typesFrozen, typesObject } from './objectBased/typesObject';
-import { ObjectMapTypeInfo, typesObjectMap } from './objectBased/typesObjectMap';
-import { RecordTypeInfo, typesRecord } from './objectBased/typesRecord';
-import { RefTypeInfo, typesRef } from './objectBased/typesRef';
-import { typesEnum } from './primitiveBased/typesEnum';
-import { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, typesLiteral } from './primitiveBased/typesPrimitive';
-import { AnyType } from './schemas';
-import { CodecTypeInfo, typesCodec } from './utility/typesCodec';
-import { typesMaybe, typesMaybeNull } from './utility/typesMaybe';
-import { OrTypeInfo, typesOr } from './utility/typesOr';
-import { RefinementTypeInfo, typesRefinement } from './utility/typesRefinement';
-import { SkipCheckTypeInfo, typesSkipCheck } from './utility/typesSkipCheck';
-import { TagTypeInfo, typesTag } from './utility/typesTag';
-import { typesUnchecked, UncheckedTypeInfo } from './utility/typesUnchecked';
-export { getTypeInfo } from './getTypeInfo';
-export { TypeInfo } from './TypeChecker';
+import { ArrayTypeInfo, typesArray } from "./arrayBased/typesArray";
+import { TupleTypeInfo, typesTuple } from "./arrayBased/typesTuple";
+import { ArraySetTypeInfo, typesArraySet } from "./objectBased/typesArraySet";
+import { typesDataModelData } from "./objectBased/typesDataModelData";
+import { ModelTypeInfo, type ModelTypeInfoProps, typesModel } from "./objectBased/typesModel";
+import { FrozenTypeInfo, ObjectTypeInfo, type ObjectTypeInfoProps, typesFrozen, typesObject } from "./objectBased/typesObject";
+import { ObjectMapTypeInfo, typesObjectMap } from "./objectBased/typesObjectMap";
+import { RecordTypeInfo, typesRecord } from "./objectBased/typesRecord";
+import { RefTypeInfo, typesRef } from "./objectBased/typesRef";
+import { typesEnum } from "./primitiveBased/typesEnum";
+import { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo, typesLiteral } from "./primitiveBased/typesPrimitive";
+import type { AnyType } from "./schemas";
+import { CodecTypeInfo, typesCodec } from "./utility/typesCodec";
+import { typesMaybe, typesMaybeNull } from "./utility/typesMaybe";
+import { OrTypeInfo, typesOr } from "./utility/typesOr";
+import { RefinementTypeInfo, typesRefinement } from "./utility/typesRefinement";
+import { SkipCheckTypeInfo, typesSkipCheck } from "./utility/typesSkipCheck";
+import { TagTypeInfo, typesTag } from "./utility/typesTag";
+import { typesUnchecked, UncheckedTypeInfo } from "./utility/typesUnchecked";
+export { getTypeInfo } from "./getTypeInfo";
+export { TypeInfo } from "./TypeChecker";
 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>;
-    null: import('./schemas').IdentityType<null>;
-    boolean: import('./schemas').IdentityType<boolean>;
-    number: import('./schemas').IdentityType<number>;
-    string: import('./schemas').IdentityType<string>;
+    undefined: import("./schemas").IdentityType<undefined>;
+    null: import("./schemas").IdentityType<null>;
+    boolean: import("./schemas").IdentityType<boolean>;
+    number: import("./schemas").IdentityType<number>;
+    string: import("./schemas").IdentityType<string>;
     or: typeof typesOr;
     maybe: typeof typesMaybe;
     maybeNull: typeof typesMaybeNull;
@@ -44,35 +44,35 @@ export declare const types: {
     tag: typeof typesTag;
     refinement: typeof typesRefinement;
     codec: typeof typesCodec;
-    integer: import('./schemas').IdentityType<number>;
-    nonEmptyString: import('./schemas').IdentityType<string>;
+    integer: import("./schemas").IdentityType<number>;
+    nonEmptyString: import("./schemas").IdentityType<string>;
     objectMap: typeof typesObjectMap;
     arraySet: typeof typesArraySet;
     tuple: typeof typesTuple;
-    bigint: import('.').CodecFromEncoded<StringConstructor, bigint>;
-    dateAsTimestamp: import('.').CodecFromEncoded<NumberConstructor, Date>;
-    dateAsIsoString: import('.').CodecFromEncoded<StringConstructor, Date>;
+    bigint: import(".").CodecFromEncoded<StringConstructor, bigint>;
+    dateAsTimestamp: import(".").CodecFromEncoded<NumberConstructor, Date>;
+    dateAsIsoString: import(".").CodecFromEncoded<StringConstructor, Date>;
     /**
      * @deprecated Prefer `types.mapFromArray(...)` for runtime `Map` values.
      */
-    mapArray<T extends AnyType>(valueType: T): import('./schemas').ArrayType<import('./schemas').ArrayType<[import('./schemas').IdentityType<string>, T]>[]>;
+    mapArray<T extends AnyType>(valueType: T): import("./schemas").ArrayType<import("./schemas").ArrayType<[import("./schemas").IdentityType<string>, T]>[]>;
     /**
      * @deprecated Prefer `types.setFromArray(...)` for runtime `Set` values.
      */
-    setArray<T extends AnyType>(valueType: T): import('./schemas').ArrayType<T[]>;
+    setArray<T extends AnyType>(valueType: T): import("./schemas").ArrayType<T[]>;
     /**
      * @deprecated Prefer `types.mapFromObject(...)` for runtime `Map` values.
      */
-    mapObject<T extends AnyType>(valueType: T): import('./schemas').RecordType<T>;
-    mapFromObject<T extends AnyType>(valueType: T): import('.').CodecFromEncoded<import('./schemas').RecordType<T>, Map<string, import('./schemas').TypeToData<T>>>;
-    mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import('.').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('.').CodecFromEncoded<import('./schemas').ArrayType<T[]>, Set<import('./schemas').TypeToData<T>> | import('mobx').ObservableSet<import('./schemas').TypeToData<T>>>;
+    mapObject<T extends AnyType>(valueType: T): import("./schemas").RecordType<T>;
+    mapFromObject<T extends AnyType>(valueType: T): import(".").CodecFromEncoded<import("./schemas").RecordType<T>, Map<string, import("./schemas").TypeToData<T>>>;
+    mapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): import(".").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(".").CodecFromEncoded<import("./schemas").ArrayType<T[]>, import("mobx").ObservableSet<import("./schemas").TypeToData<T>> | Set<import("./schemas").TypeToData<T>>>;
     /**
      * @deprecated Prefer `types.dateAsIsoString` instead.
      */
-    dateString: import('./schemas').IdentityType<string>;
+    dateString: import("./schemas").IdentityType<string>;
     /**
      * @deprecated Prefer `types.dateAsTimestamp` instead.
      */
-    dateTimestamp: import('./schemas').IdentityType<number>;
+    dateTimestamp: import("./schemas").IdentityType<number>;
 };

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

@@ -1,5 +1,5 @@
-import { SimplifyObject } from '../../utils/types';
-import { ArrayType, ObjectOptionalKeys, ObjectType, ObjectTypeFunction, RecordType, TypeToData } from '../schemas';
+import type { SimplifyObject } from "../../utils/types";
+import type { ArrayType, ObjectOptionalKeys, ObjectType, ObjectTypeFunction, RecordType, TypeToData } from "../schemas";
 type ArrayStoredData<S extends readonly unknown[]> = number extends S["length"] ? Array<TypeToStoredData<S[number]>> : {
     [k in keyof S]: TypeToStoredData<S[k]>;
 };

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

@@ -1 +1 @@
-export declare const typesBigInt: import('./typesCodecCore').CodecFromEncoded<StringConstructor, bigint>;
+export declare const typesBigInt: import("./typesCodecCore").CodecFromEncoded<StringConstructor, bigint>;

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

@@ -1,7 +1,7 @@
-import { typesBigInt } from './typesBigInt';
-import { CodecTypeInfo, typesCodec } from './typesCodecCore';
-import { createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker } from './typesCodecSupport';
-import { typesDateAsIsoString, typesDateAsTimestamp } from './typesDate';
-import { typesMapFromArray, typesMapFromObject } from './typesMap';
-import { typesSetFromArray } from './typesSet';
+import { typesBigInt } from "./typesBigInt";
+import { CodecTypeInfo, typesCodec } from "./typesCodecCore";
+import { createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker } from "./typesCodecSupport";
+import { typesDateAsIsoString, typesDateAsTimestamp } from "./typesDate";
+import { typesMapFromArray, typesMapFromObject } from "./typesMap";
+import { typesSetFromArray } from "./typesSet";
 export { CodecTypeInfo, createCodecPropTransform, resolveCodecSupport, resolveStoredType, resolveStoredTypeChecker, typesBigInt, typesCodec, typesDateAsIsoString, typesDateAsTimestamp, typesMapFromArray, typesMapFromObject, typesSetFromArray, };

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

@@ -1,7 +1,7 @@
-import { ModelPropTransform } from '../../modelShared/prop';
-import { AnyStandardType, AnyType, CodecType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from '../schemas';
-import { TypeCheckerBaseType, TypeInfo } from '../TypeChecker';
-import { TypeToStoredData } from './typeToStoredData';
+import type { ModelPropTransform } from "../../modelShared/prop";
+import type { AnyStandardType, AnyType, CodecType, TypeToData, TypeToSnapshotIn, TypeToSnapshotOut } from "../schemas";
+import { TypeCheckerBaseType, TypeInfo } from "../TypeChecker";
+import type { TypeToStoredData } from "./typeToStoredData";
 export interface RuntimeAdapter<Stored, Runtime> {
     toRuntime(stored: Stored, setStored?: (stored: Stored) => void): Runtime;
     toStored(runtime: Runtime): Stored;

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

@@ -1,7 +1,7 @@
-import { ModelPropTransform } from '../../modelShared/prop';
-import { AnyStandardType, AnyType } from '../schemas';
-import { ResolvedCodecSupport } from './typesCodecCore';
+import type { ModelPropTransform } from "../../modelShared/prop";
+import type { AnyStandardType, AnyType } from "../schemas";
+import { type ResolvedCodecSupport } from "./typesCodecCore";
 export declare function resolveCodecSupport(type: AnyType): ResolvedCodecSupport;
 export declare function resolveStoredType(type: AnyType): AnyStandardType;
-export declare function resolveStoredTypeChecker(type: AnyType): import('../TypeChecker').TypeChecker;
+export declare function resolveStoredTypeChecker(type: AnyType): import("../TypeChecker").TypeChecker;
 export declare function createCodecPropTransform(type: AnyType): ModelPropTransform<any, unknown>;

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

@@ -1,2 +1,2 @@
-export declare const typesDateAsTimestamp: import('./typesCodecCore').CodecFromEncoded<NumberConstructor, Date>;
-export declare const typesDateAsIsoString: import('./typesCodecCore').CodecFromEncoded<StringConstructor, Date>;
+export declare const typesDateAsTimestamp: import("./typesCodecCore").CodecFromEncoded<NumberConstructor, Date>;
+export declare const typesDateAsIsoString: import("./typesCodecCore").CodecFromEncoded<StringConstructor, Date>;

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

@@ -1,4 +1,4 @@
-import { AnyType, ArrayType, RecordType, TypeToData } from '../schemas';
-import { CodecFromEncoded } from './typesCodecCore';
+import type { AnyType, ArrayType, RecordType, TypeToData } from "../schemas";
+import type { CodecFromEncoded } from "./typesCodecCore";
 export declare function typesMapFromObject<TValueType extends AnyType>(valueType: TValueType): CodecFromEncoded<RecordType<TValueType>, Map<string, TypeToData<TValueType>>>;
 export declare function typesMapFromArray<TKeyType extends AnyType, TValueType extends AnyType>(keyType: TKeyType, valueType: TValueType): CodecFromEncoded<ArrayType<ArrayType<[TKeyType, TValueType]>[]>, Map<TypeToData<TKeyType>, TypeToData<TValueType>>>;

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

@@ -1,4 +1,4 @@
-import { AnyType, IdentityType } from '../schemas';
+import type { AnyType, IdentityType } from "../schemas";
 /**
  * A type that represents either a type or undefined.
  * Syntactic sugar for `types.or(baseType, types.undefined)`

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

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that represents the union of several other types (a | b | c | ...).
  * Accepts a dispatcher that, given a snapshot, returns the type

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

@@ -1,6 +1,6 @@
-import { AnyStandardType, AnyType, TypeToData } from '../schemas';
-import { TypeCheckError } from '../TypeCheckError';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType, TypeToData } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
+import { TypeCheckError } from "../TypeCheckError";
 /**
  * A refinement over a given type. This allows you to do extra checks
  * over models, ensure numbers are integers, etc.

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

@@ -1,4 +1,4 @@
-import { ObservableSet } from 'mobx';
-import { AnyType, ArrayType, TypeToData } from '../schemas';
-import { CodecFromEncoded } from './typesCodecCore';
+import type { ObservableSet } from "mobx";
+import type { AnyType, ArrayType, TypeToData } from "../schemas";
+import type { CodecFromEncoded } from "./typesCodecCore";
 export declare function typesSetFromArray<TValueType extends AnyType>(valueType: TValueType): CodecFromEncoded<ArrayType<TValueType[]>, Set<TypeToData<TValueType>> | ObservableSet<TypeToData<TValueType>>>;

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

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that wraps another type but skips runtime validation.
  * Unlike `types.unchecked()`, this preserves the wrapped type's

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

@@ -1,5 +1,5 @@
-import { AnyStandardType, AnyType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { AnyStandardType, AnyType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * Wrap a given type with tag information.
  * This allows you to associate metadata with the type of a prop that

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

@@ -1,5 +1,5 @@
-import { IdentityType } from '../schemas';
-import { TypeInfo } from '../TypeChecker';
+import type { IdentityType } from "../schemas";
+import { TypeInfo } from "../TypeChecker";
 /**
  * A type that represents a given value that won't be type checked.
  * This is basically a way to bail out of the runtime type checking system.

package/dist/types/utils/ModelPool.d.ts

@@ -1,4 +1,4 @@
-import { AnyModel } from '../model/BaseModel';
+import type { AnyModel } from "../model/BaseModel";
 /**
  * A view of the models under a node, as they were when the pool was created.
  * Must be released once no longer used.

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

@@ -1,4 +1,4 @@
-import { AnyModel } from '../model/BaseModel';
+import type { AnyModel } from "../model/BaseModel";
 declare const arraySetBase: abstract new (data: any) => AnyModel & {
     readonly $: {
         items: any[];

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

@@ -1,4 +1,4 @@
-import { AnyModel } from '../model/BaseModel';
+import type { AnyModel } from "../model/BaseModel";
 declare const objectMapBase: abstract new (data: any) => AnyModel & {
     readonly $: {
         items: Record<string, any>;

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

@@ -1,4 +1,4 @@
-import { ObservableMap } from 'mobx';
+import { type ObservableMap } from "mobx";
 type Ts6MapExtras<K, V> = {
     getOrInsert(key: K, defaultValue: V): V;
     getOrInsertComputed(key: K, callback: (key: K) => V): V;

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

@@ -1,4 +1,4 @@
-import { ObservableSet } from 'mobx';
+import { type ObservableSet } from "mobx";
 /**
  * Wraps an observable array to offer a set like interface.
  *

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

@@ -1,4 +1,4 @@
-export * from './ArraySet';
-export * from './asMap';
-export * from './asSet';
-export * from './ObjectMap';
+export * from "./ArraySet";
+export * from "./asMap";
+export * from "./asSet";
+export * from "./ObjectMap";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobx-keystone",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "A MobX powered state management solution based on data trees with first class support for TypeScript, snapshots, patches and much more",
   "keywords": [
     "mobx",
@@ -50,19 +50,6 @@
     "CHANGELOG.md",
     "README.md"
   ],
-  "scripts": {
-    "quick-build": "tsc",
-    "quick-build-tests": "tsc -p test",
-    "copy-root-files": "shx cp ../../README.md . && shx cp ../../LICENSE . && shx cp ../../CHANGELOG.md .",
-    "build": "pnpm run quick-build && pnpm run copy-root-files && shx rm -rf dist && vite build && pnpm run check-declarations && shx cp dist/mobx-keystone.esm.mjs dist/mobx-keystone.esm.js",
-    "check-declarations": "tsc -p scripts/tsconfig.check-declarations.json",
-    "test": "vitest run",
-    "test:ci": "vitest run --coverage",
-    "test:perf": "pnpm run build && pnpm run test:perf:run",
-    "test:perf:run": "cd perf_bench && NODE_ENV=production TS_NODE_COMPILER=@typescript/typescript6 /usr/bin/time node --expose-gc --require ts-node/register ./report.ts",
-    "memtest": "cd perf_bench && NODE_ENV=production TS_NODE_COMPILER=@typescript/typescript6 node --expose-gc --require ts-node/register ./memtest.ts",
-    "build-docs": "shx rm -rf ../../apps/site/generated-api && node --import ./scripts/typedoc-typescript6-register.mjs ./node_modules/typedoc/dist/cli.js --options ./typedocconfig.js src/index.ts"
-  },
   "peerDependencies": {
     "mobx": "^7.0.0 || ^6.0.0 || ^5.0.0 || ^4.0.0"
   },
@@ -77,7 +64,7 @@
     "@types/babel__core": "^7.20.5",
     "@types/node": "^26.6.2",
     "@typescript/typescript6": "^6.0.2",
-    "@vitest/coverage-v8": "^5.0.1",
+    "@vitest/coverage-v8": "catalog:",
     "expect-type": "^1.4.0",
     "mobx-v4": "npm:mobx@^4.15.7",
     "mobx-v5": "npm:mobx@^5.15.7",
@@ -89,9 +76,9 @@
     "typedoc-docusaurus-theme": "^1.4.3",
     "typedoc-plugin-markdown": "^4.13.1",
     "typescript": "^7.0.2",
-    "vite": "^8.3.1",
-    "vite-plugin-dts": "^5.1.1",
-    "vitest": "^5.0.1"
+    "vite": "catalog:",
+    "vite-plus": "catalog:",
+    "vitest": "catalog:"
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",

package/src/action/modelAction.ts

@@ -8,7 +8,7 @@ import { wrapInAction } from "./wrapInAction"
  * Decorator that turns a function into a model action.
  */
 export function modelAction(...args: any[]): void {
-  // biome-ignore lint/correctness/noVoidTypeReturn: proper way to declare a decorator
+  // Proper way to declare a decorator
   return decorateWrapMethodOrField("modelAction", args, (data, fn) => {
     if (isModelAction(fn)) {
       return fn

package/src/action/modelFlow.ts

@@ -163,7 +163,7 @@ export function isModelFlow(fn: unknown) {
  * Decorator that turns a function generator into a model flow.
  */
 export function modelFlow(...args: any[]): void {
-  // biome-ignore lint/correctness/noVoidTypeReturn: proper way to declare a decorator
+  // Proper way to declare a decorator
   return decorateWrapMethodOrField("modelFlow", args, (data, fn) => {
     if (isModelFlow(fn)) {
       return fn

package/src/dataModel/BaseDataModel.ts

@@ -1,4 +1,4 @@
-import { propsTypeSymbol } from "../modelShared/BaseModelShared"
+import { type propsTypeSymbol } from "../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../modelShared/modelInfo"
 import { getInternalModelClassPropsInfo } from "../modelShared/modelPropsInfo"
 import {
@@ -13,8 +13,8 @@ import { getSnapshot } from "../snapshot/getSnapshot"
 import { isTreeNode } from "../tweaker/core"
 import { toTreeNode } from "../tweaker/tweak"
 import { typesDataModelData } from "../types/objectBased/typesDataModelData"
-import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
+import type { TypeCheckError } from "../types/TypeCheckError"
 import { clonePlainObject, failure, hasOwnProp, isObject, setProtoProp } from "../utils"
 import { getOrCreate } from "../utils/mapUtils"
 import type { DataModelConstructorOptions } from "./DataModelConstructorOptions"
@@ -73,7 +73,7 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
     }
 
     const constructorOptions =
-      // biome-ignore lint/complexity/noArguments: internal factory code passes hidden constructor options through super().
+      // oxlint-disable-next-line eslint/prefer-rest-params -- internal factory code passes hidden constructor options through super().
       arguments[1] as DataModelConstructorOptions
     const { modelClass: _modelClass } = constructorOptions
     const modelClass = _modelClass!
@@ -140,7 +140,7 @@ export abstract class BaseDataModel<TProps extends ModelProps> {
 
     const instance = instancesForModelClass.get(tweakedData)
     if (instance) {
-      // biome-ignore lint/correctness/noConstructorReturn: no other way to return an instance
+      // oxlint-disable-next-line eslint/no-constructor-return -- no other way to return an instance
       return instance
     }
 
@@ -189,6 +189,6 @@ export interface AnyDataModel extends BaseDataModel<any> {}
  * A data model class declaration, made of a base model and the model interface.
  */
 export type DataModelClassDeclaration<BaseModelClass, ModelInterface> = BaseModelClass & {
-  // biome-ignore lint/style/useShorthandFunctionType: make type recursive
+  // oxlint-disable-next-line typescript/prefer-function-type -- make type recursive
   (...args: any[]): ModelInterface
 }

package/src/model/BaseModel.ts

@@ -1,9 +1,9 @@
 import { observable } from "mobx"
 import {
-  fromSnapshotOverrideTypeSymbol,
+  type fromSnapshotOverrideTypeSymbol,
   type ModelClass,
-  propsTypeSymbol,
-  toSnapshotOverrideTypeSymbol,
+  type propsTypeSymbol,
+  type toSnapshotOverrideTypeSymbol,
 } from "../modelShared/BaseModelShared"
 import { modelInfoByClass } from "../modelShared/modelInfo"
 import type {
@@ -15,12 +15,12 @@ import { getSnapshot } from "../snapshot/getSnapshot"
 import { setModelInitialDataSnapshot } from "../snapshot/modelInitialData"
 import type { SnapshotInOfModel, SnapshotOutOfModel } from "../snapshot/SnapshotOf"
 import { typesModel } from "../types/objectBased/typesModel"
-import type { TypeCheckError } from "../types/TypeCheckError"
 import { typeCheck } from "../types/typeCheck"
+import type { TypeCheckError } from "../types/TypeCheckError"
 import { assertIsObject, failure, nodeObservableOptions } from "../utils"
 import { getModelIdPropertyName } from "./getModelMetadata"
-import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { modelIdKey, modelTypeKey } from "./metadata"
+import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { internalFromSnapshotModel, internalNewModel } from "./newModel"
 import { assertIsModelClass } from "./utils"
 
@@ -134,7 +134,7 @@ export abstract class BaseModel<
   constructor(data: ModelPropsToTransformedCreationData<TProps>) {
     const initialData = data as any
     const constructorOptions =
-      // biome-ignore lint/complexity/noArguments: internal factory code passes hidden constructor options through super().
+      // oxlint-disable-next-line eslint/prefer-rest-params -- internal factory code passes hidden constructor options through super().
       arguments[1] as ModelConstructorOptions
     const { snapshotInitialData, modelClass, generateNewIds } = constructorOptions
 
@@ -205,6 +205,7 @@ export interface AnyModel extends BaseModel<any, any, any, any> {}
  * @param type Abstract model class.
  * @returns
  */
+// oxlint-disable-next-line typescript/no-wrapper-object-types -- part of the public signature
 export function abstractModelClass<T>(type: T): T & Object {
   return type as any
 }

package/src/model/mixins.ts

@@ -2,7 +2,7 @@ import {
   type AbstractModelClass,
   type ModelClass,
   modelClass,
-  propsTypeSymbol,
+  type propsTypeSymbol,
 } from "../modelShared/BaseModelShared"
 import type { ModelProps, ModelPropsToTransformedData } from "../modelShared/prop"
 import type { AnyModel, BaseModelKeys } from "./BaseModel"

package/src/model/newModel.ts

@@ -27,8 +27,8 @@ import { failure, hasOwnProp, inDevMode, makePropReadonly } from "../utils"
 import { setIfDifferent, setIfDifferentWithReturn } from "../utils/setIfDifferent"
 import type { AnyModel } from "./BaseModel"
 import { getModelIdPropertyName } from "./getModelMetadata"
-import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { modelTypeKey } from "./metadata"
+import type { ModelConstructorOptions } from "./ModelConstructorOptions"
 import { assertIsModelClass } from "./utils"
 
 /**

package/src/modelShared/modelDecorator.ts

@@ -43,9 +43,7 @@ export const model =
 // the model instance type is checked through `prototype` rather than through a typed constructor
 // signature, since comparing constructor signatures would compute the (expensive) model creation data
 // type of every decorated class
-type ModelDecoratorTarget = (new (
-  ...args: any
-) => any) & {
+type ModelDecoratorTarget = (new (...args: any) => any) & {
   prototype: AnyModel | AnyDataModel
 }
 
@@ -191,7 +189,7 @@ function tsDecorate(
     r = (Reflect as any).decorate(decorators, target, key, desc)
   } else {
     for (
-      // biome-ignore lint/correctness/noInnerDeclarations: minified file
+      // oxlint-disable-next-line eslint/no-inner-declarations, eslint/no-var -- minified file
       var i = decorators.length - 1;
       i >= 0;
       i--
@@ -201,8 +199,8 @@ function tsDecorate(
       }
     }
   }
-  // biome-ignore lint/complexity/noCommaOperator: minified file
-  return c > 3 && r && Object.defineProperty(target, key, r), r
+  // oxlint-disable-next-line eslint/no-sequences -- minified file
+  return (c > 3 && r && Object.defineProperty(target, key, r), r)
 }
 
 /**

package/src/modelShared/modelInfo.ts

@@ -58,10 +58,11 @@ export function setModelInfo(modelInfo: ModelInfo, unwrappedClass: ModelClass<an
   // registration of a model
   const baseModelInfo = findModelInfoForPrototype(Object.getPrototypeOf(unwrappedClass.prototype))
   const ancestorDistances = new Map<string, number>()
-  baseModelInfo &&
+  if (baseModelInfo) {
     ancestorDistancesByModelInfo.get(baseModelInfo)?.forEach((distance, name) => {
       ancestorDistances.set(name, distance + 1)
     })
+  }
   ancestorDistances.set(modelInfo.name, 0)
   ancestorDistancesByModelInfo.set(modelInfo, ancestorDistances)
   ancestorDistancesByModelName.set(modelInfo.name, ancestorDistances)

package/src/modelShared/sharedInternalModel.ts

@@ -11,8 +11,8 @@ import type { DataModelMetadata } from "../dataModel/getDataModelMetadata"
 import { getGlobalConfig } from "../globalConfig/globalConfig"
 import { type AnyModel, BaseModel, baseModelPropNames } from "../model/BaseModel"
 import type { ModelMetadata } from "../model/getModelMetadata"
-import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { modelTypeKey } from "../model/metadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { typesObject } from "../types/objectBased/typesObject"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import type { AnyType } from "../types/schemas"

package/src/ref/Ref.ts

@@ -1,5 +1,5 @@
-import { Model } from "../model/Model"
 import { modelTypeKey } from "../model/metadata"
+import { Model } from "../model/Model"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { typesString } from "../types/primitiveBased/typesPrimitive"
 import { tProp } from "../types/tProp"

package/src/snapshot/SnapshotterAndReconcilerPriority.ts

@@ -1,10 +1,11 @@
 /**
  * @internal
  */
-// biome-ignore lint/style/useEnumInitializers: that's ok, it is not serialized
+/* oxlint-disable typescript/prefer-enum-initializers -- that's ok, it is not serialized */
 export enum SnapshotterAndReconcilerPriority {
   Array,
   Frozen,
   Model,
   PlainObject,
 }
+/* oxlint-enable typescript/prefer-enum-initializers */

package/src/snapshot/fromModelSnapshot.ts

@@ -1,7 +1,7 @@
 import type { AnyModel } from "../model/BaseModel"
 import { getModelIdPropertyName } from "../model/getModelMetadata"
-import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { modelTypeKey } from "../model/metadata"
+import type { ModelConstructorOptions } from "../model/ModelConstructorOptions"
 import { getModelOrSnapshotTypeAndId, getSnapshotModelType } from "../model/utils"
 import type { ModelClass } from "../modelShared/BaseModelShared"
 import { getModelInfoForName, getModelNotRegisteredErrorMessage } from "../modelShared/modelInfo"

package/src/snapshot/fromSnapshot.ts

@@ -83,7 +83,7 @@ export function fromSnapshot<T>(arg1: any, arg2: any, arg3?: any): T {
     let snapshot: any
     let unprocessedSnapshot: unknown
     let options: Partial<FromSnapshotOptions> | undefined
-    // biome-ignore lint/complexity/noArguments: overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
+    // oxlint-disable-next-line eslint/prefer-rest-params -- overload resolution needs the real call arity to distinguish omitted snapshots from omitted type args.
     const standardType = arguments.length >= 2 ? resolveStandardTypeNoThrow(arg1) : undefined
 
     if (isLateTypeChecker(arg1) || arg1 instanceof TypeChecker || standardType) {