mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/index.mjs

@@ -0,0 +1,97 @@
+export { applyAction } from "./action/applyAction.mjs";
+export { applyDelete, internalApplyDelete } from "./action/applyDelete.mjs";
+export { applyMethodCall, internalApplyMethodCall } from "./action/applyMethodCall.mjs";
+export { applySet } from "./action/applySet.mjs";
+export { BuiltInAction, isBuiltInAction } from "./action/builtInActions.mjs";
+export { ActionContextActionType, ActionContextAsyncStepType, getCurrentActionContext, setCurrentActionContext } from "./action/context.mjs";
+export { HookAction, isHookAction } from "./action/hookActions.mjs";
+export { isModelAction, modelActionSymbol } from "./action/isModelAction.mjs";
+export { addActionMiddleware, getActionMiddlewares } from "./action/middleware.mjs";
+export { modelAction } from "./action/modelAction.mjs";
+export { _async, _await, flow, isModelFlow, modelFlow } from "./action/modelFlow.mjs";
+export { runUnprotected } from "./action/runUnprotected.mjs";
+export { deserializeActionCall, deserializeActionCallArgument, registerActionCallArgumentSerializer, serializeActionCall, serializeActionCallArgument } from "./actionMiddlewares/actionSerialization/actionSerialization.mjs";
+export { applySerializedActionAndSyncNewModelIds, applySerializedActionAndTrackNewModelIds } from "./actionMiddlewares/actionSerialization/applySerializedAction.mjs";
+export { cannotSerialize } from "./actionMiddlewares/actionSerialization/core.mjs";
+export { ActionTrackingResult, actionTrackingMiddleware, simplifyActionContext } from "./actionMiddlewares/actionTrackingMiddleware.mjs";
+export { onActionMiddleware } from "./actionMiddlewares/onActionMiddleware.mjs";
+export { readonlyMiddleware } from "./actionMiddlewares/readonlyMiddleware.mjs";
+export { transaction, transactionMiddleware } from "./actionMiddlewares/transactionMiddleware.mjs";
+export { UndoEventType, UndoManager, UndoStore, isGlobalUndoRecordingDisabled, undoMiddleware, withoutUndo } from "./actionMiddlewares/undoMiddleware.mjs";
+export { computedTree, isComputedTreeNode } from "./computedTree/computedTree.mjs";
+export { createContext } from "./context/context.mjs";
+export { BaseDataModel, baseDataModelPropNames } from "./dataModel/BaseDataModel.mjs";
+export { DataModel, ExtendedDataModel } from "./dataModel/DataModel.mjs";
+export { getDataModelMetadata } from "./dataModel/getDataModelMetadata.mjs";
+export { assertIsDataModel, assertIsDataModelClass, isDataModel, isDataModelClass } from "./dataModel/utils.mjs";
+export { Frozen, FrozenCheckMode, frozen, frozenKey, isFrozenSnapshot } from "./frozen/Frozen.mjs";
+export { ModelAutoTypeCheckingMode, getGlobalConfig, isModelAutoTypeCheckingEnabled, setGlobalConfig } from "./globalConfig/globalConfig.mjs";
+export { BaseModel, abstractModelClass, baseModelPropNames, modelIdPropertyNameSymbol, modelSnapshotInWithMetadata, modelSnapshotOutWithMetadata } from "./model/BaseModel.mjs";
+export { getModelIdPropertyName, getModelMetadata } from "./model/getModelMetadata.mjs";
+export { isReservedModelKey, modelIdKey, modelTypeKey } from "./model/metadata.mjs";
+export { ExtendedModel, Model } from "./model/Model.mjs";
+export { assertIsModel, assertIsModelClass, isModel, isModelClass, isModelSnapshot } from "./model/utils.mjs";
+export { fromSnapshotOverrideTypeSymbol, modelClass, modelInitializedSymbol, propsTypeSymbol, toSnapshotOverrideTypeSymbol } from "./modelShared/BaseModelShared.mjs";
+export { decoratedModel, model } from "./modelShared/modelDecorator.mjs";
+export { idProp, noDefaultValue, prop } from "./modelShared/prop.mjs";
+export { detach } from "./parent/detach.mjs";
+export { findChildren } from "./parent/findChildren.mjs";
+export { findParent, findParentPath } from "./parent/findParent.mjs";
+export { getChildrenObjects } from "./parent/getChildrenObjects.mjs";
+export { onChildAttachedTo } from "./parent/onChildAttachedTo.mjs";
+export { fastGetParent, fastGetParentIncludingDataObjects, fastGetParentPath, fastGetParentPathIncludingDataObjects, fastGetRoot, fastGetRootPath, fastIsModelDataObject, getParent, getParentPath, getParentToChildPath, getRoot, getRootPath, isModelDataObject, isRoot, resolvePath, resolvePathCheckingIds, skipIdChecking } from "./parent/path.mjs";
+export { isChildOfParent, isParentOfChild } from "./parent/path2.mjs";
+export { WalkTreeMode, computedWalkTreeAggregate, walkTree } from "./parent/walkTree.mjs";
+export { applyPatches, internalApplyPatches } from "./patch/applyPatches.mjs";
+export { InternalPatchRecorder, onGlobalPatches, onPatches } from "./patch/emitPatch.mjs";
+export { jsonPatchToPatch, jsonPointerToPath, patchToJsonPatch, pathToJsonPointer } from "./patch/jsonPatch.mjs";
+export { internalPatchRecorder, patchRecorder } from "./patch/patchRecorder.mjs";
+export { connectReduxDevTools } from "./redux/connectReduxDevTools.mjs";
+export { actionCallToReduxAction, asReduxStore, reduxActionType } from "./redux/redux.mjs";
+export { getModelRefId, getRefsResolvingTo, internalCustomRef, resolveId } from "./ref/core.mjs";
+export { customRef } from "./ref/customRef.mjs";
+export { Ref, isRefOfType } from "./ref/Ref.mjs";
+export { rootRef } from "./ref/rootRef.mjs";
+export { fastGetRootStore, fastIsRootStore, getRootStore, isRootStore, registerRootStore, unregisterRootStore } from "./rootStore/rootStore.mjs";
+export { applySnapshot, internalApplySnapshot } from "./snapshot/applySnapshot.mjs";
+export { clone } from "./snapshot/clone.mjs";
+export { fromSnapshot, internalFromSnapshot, observableOptions, registerSnapshotter } from "./snapshot/fromSnapshot.mjs";
+export { getSnapshot } from "./snapshot/getSnapshot.mjs";
+export { onSnapshot } from "./snapshot/onSnapshot.mjs";
+export { arrayActions } from "./standardActions/arrayActions.mjs";
+export { objectActions } from "./standardActions/objectActions.mjs";
+export { standaloneAction, standaloneFlow } from "./standardActions/standaloneActions.mjs";
+export { arrayToMapTransform, objectToMapTransform } from "./transforms/asMap.mjs";
+export { arrayToSetTransform } from "./transforms/asSet.mjs";
+export { stringToBigIntTransform } from "./transforms/bigint.mjs";
+export { isoStringToDateTransform, timestampToDateTransform } from "./transforms/date.mjs";
+export { deepEquals } from "./treeUtils/deepEquals.mjs";
+export { Draft, draft } from "./treeUtils/draft.mjs";
+export { SandboxManager, getNodeSandboxManager, isSandboxedNode, sandbox } from "./treeUtils/sandbox.mjs";
+export { assertIsTreeNode, assertTweakedObject, isTreeNode, isTweakedObject, runWithoutSnapshotOrPatches, runningWithoutSnapshotOrPatches, tweakedObjects } from "./tweaker/core.mjs";
+export { registerTweaker, toTreeNode, tryUntweak, tweak } from "./tweaker/tweak.mjs";
+export { tProp } from "./types/tProp.mjs";
+export { typeCheck } from "./types/typeCheck.mjs";
+export { TypeCheckError } from "./types/TypeCheckError.mjs";
+export { types } from "./types/types.mjs";
+export { MobxKeystoneError, addHiddenProp, addLateInitializationFunction, assertIsFunction, assertIsMap, assertIsObject, assertIsObservableArray, assertIsObservableObject, assertIsPlainObject, assertIsPrimitive, assertIsSet, assertIsString, decorateWrapMethodOrField, deleteFromArray, failure, getMobxVersion, identityFn, inDevMode, isArray, isJSONPrimitive, isMap, isObject, isPlainObject, isPrimitive, isSet, lazy, logWarning, makePropReadonly, mobx6, namespace, propNameToSetterName, runAfterNewSymbol, runBeforeOnInitSymbol, runLateInitializationFunctions } from "./utils/index.mjs";
+export { tag } from "./utils/tag.mjs";
+export { ArraySet, arraySet } from "./wrappers/ArraySet.mjs";
+export { asMap, mapToArray, mapToObject } from "./wrappers/asMap.mjs";
+export { asSet, setToArray } from "./wrappers/asSet.mjs";
+export { ObjectMap, objectMap } from "./wrappers/ObjectMap.mjs";
+export { getTypeInfo } from "./types/getTypeInfo.mjs";
+export { TypeInfo } from "./types/TypeChecker.mjs";
+export { BooleanTypeInfo, LiteralTypeInfo, NumberTypeInfo, StringTypeInfo } from "./types/primitiveBased/primitives.mjs";
+export { FrozenTypeInfo, ObjectTypeInfo } from "./types/objectBased/object.mjs";
+export { ObjectMapTypeInfo } from "./types/objectBased/objectMap.mjs";
+export { RefinementTypeInfo } from "./types/utility/refinement.mjs";
+export { RecordTypeInfo } from "./types/objectBased/record.mjs";
+export { RefTypeInfo } from "./types/objectBased/ref.mjs";
+export { UncheckedTypeInfo } from "./types/utility/unchecked.mjs";
+export { ArraySetTypeInfo } from "./types/objectBased/arraySet.mjs";
+export { ArrayTypeInfo } from "./types/arrayBased/array.mjs";
+export { ModelTypeInfo } from "./types/objectBased/model.mjs";
+export { OrTypeInfo } from "./types/utility/or.mjs";
+export { TupleTypeInfo } from "./types/arrayBased/tuple.mjs";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgubWpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/src/model/BaseModel.mjs

@@ -0,0 +1,118 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var _a, _b, _c, _d, _e;
+import { observable } from "mobx";
+import { propsTypeSymbol, fromSnapshotOverrideTypeSymbol, toSnapshotOverrideTypeSymbol } from "../modelShared/BaseModelShared.mjs";
+import { modelInfoByClass } from "../modelShared/modelInfo.mjs";
+import { getSnapshot } from "../snapshot/getSnapshot.mjs";
+import { typesModel } from "../types/objectBased/model.mjs";
+import { typeCheck } from "../types/typeCheck.mjs";
+import { failure, assertIsObject } from "../utils/index.mjs";
+import { getModelIdPropertyName } from "./getModelMetadata.mjs";
+import { modelTypeKey, modelIdKey } from "./metadata.mjs";
+import { internalNewModel } from "./newModel.mjs";
+import { assertIsModelClass } from "./utils.mjs";
+const modelIdPropertyNameSymbol = Symbol("modelIdPropertyName");
+class BaseModel {
+  constructor(data) {
+    __publicField(this, _a);
+    __publicField(this, _b);
+    __publicField(this, _c);
+    __publicField(this, _d);
+    __publicField(this, _e);
+    __publicField(this, "$");
+    let initialData = data;
+    const { snapshotInitialData, modelClass, generateNewIds } = arguments[1];
+    Object.setPrototypeOf(this, modelClass.prototype);
+    const self = this;
+    delete self[propsTypeSymbol];
+    delete self[fromSnapshotOverrideTypeSymbol];
+    delete self[toSnapshotOverrideTypeSymbol];
+    delete self[modelIdPropertyNameSymbol];
+    if (!snapshotInitialData) {
+      assertIsObject(initialData, "initialData");
+      internalNewModel(this, observable.object(initialData, void 0, { deep: false }), {
+        modelClass,
+        generateNewIds: true
+      });
+    } else {
+      internalNewModel(this, void 0, { modelClass, snapshotInitialData, generateNewIds });
+    }
+  }
+  get [(_a = propsTypeSymbol, _b = fromSnapshotOverrideTypeSymbol, _c = toSnapshotOverrideTypeSymbol, _d = modelIdPropertyNameSymbol, _e = modelTypeKey, modelIdKey)]() {
+    const idProp = getModelIdPropertyName(this.constructor);
+    return idProp ? this.$[idProp] : void 0;
+  }
+  set [modelIdKey](newId) {
+    const idProp = getModelIdPropertyName(this.constructor);
+    if (!idProp) {
+      throw failure("$modelId cannot be set when there is no idProp set in the model");
+    }
+    this.$[idProp] = newId;
+  }
+  getRefId() {
+    return this[modelIdKey];
+  }
+  typeCheck() {
+    const type = typesModel(this.constructor);
+    return typeCheck(type, this);
+  }
+  toString(options) {
+    const finalOptions = __spreadValues({
+      withData: true
+    }, options);
+    const firstPart = `${this.constructor.name}#${this[modelTypeKey]}`;
+    return finalOptions.withData ? `[${firstPart} ${JSON.stringify(getSnapshot(this))}]` : `[${firstPart}]`;
+  }
+}
+const baseModelPropNames = /* @__PURE__ */ new Set([
+  modelTypeKey,
+  modelIdKey,
+  "onInit",
+  "$",
+  "getRefId",
+  "onAttachedToRootStore",
+  "typeCheck"
+]);
+function abstractModelClass(type) {
+  return type;
+}
+function modelSnapshotInWithMetadata(modelClass, snapshot) {
+  assertIsModelClass(modelClass, "modelClass");
+  assertIsObject(snapshot, "initialData");
+  const modelInfo = modelInfoByClass.get(modelClass);
+  return __spreadProps(__spreadValues({}, snapshot), {
+    [modelTypeKey]: modelInfo.name
+  });
+}
+function modelSnapshotOutWithMetadata(modelClass, snapshot) {
+  assertIsModelClass(modelClass, "modelClass");
+  assertIsObject(snapshot, "initialData");
+  const modelInfo = modelInfoByClass.get(modelClass);
+  return __spreadProps(__spreadValues({}, snapshot), {
+    [modelTypeKey]: modelInfo.name
+  });
+}
+export { BaseModel, abstractModelClass, baseModelPropNames, modelIdPropertyNameSymbol, modelSnapshotInWithMetadata, modelSnapshotOutWithMetadata };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"BaseModel.mjs","sources":["../../../src/model/BaseModel.ts"],"sourcesContent":["import { observable } from \"mobx\"\nimport {\n  fromSnapshotOverrideTypeSymbol,\n  ModelClass,\n  propsTypeSymbol,\n  toSnapshotOverrideTypeSymbol,\n} from \"../modelShared/BaseModelShared\"\nimport { modelInfoByClass } from \"../modelShared/modelInfo\"\nimport type {\n  ModelProps,\n  ModelPropsToData,\n  ModelPropsToTransformedCreationData,\n} from \"../modelShared/prop\"\nimport { getSnapshot } from \"../snapshot/getSnapshot\"\nimport type { SnapshotInOfModel, SnapshotOutOfModel } from \"../snapshot/SnapshotOf\"\nimport { typesModel } from \"../types/objectBased/model\"\nimport { typeCheck } from \"../types/typeCheck\"\nimport type { TypeCheckError } from \"../types/TypeCheckError\"\nimport { assertIsObject, failure } from \"../utils\"\nimport { getModelIdPropertyName } from \"./getModelMetadata\"\nimport { modelIdKey, modelTypeKey } from \"./metadata\"\nimport type { ModelConstructorOptions } from \"./ModelConstructorOptions\"\nimport { internalNewModel } from \"./newModel\"\nimport { assertIsModelClass } from \"./utils\"\n\n/**\n * @ignore\n */\nexport const modelIdPropertyNameSymbol = Symbol(\"modelIdPropertyName\")\n\n/**\n * Base abstract class for models. Use `Model` instead when extending.\n *\n * Never override the constructor, use `onInit` or `onAttachedToRootStore` instead.\n *\n * @typeparam Data Data type.\n * @typeparam CreationData Creation data type.\n * @typeparam ModelIdPropertyName Model id property name.\n */\nexport abstract class BaseModel<\n  TProps extends ModelProps,\n  FromSnapshotOverride extends Record<string, any>,\n  ToSnapshotOverride extends Record<string, any>,\n  ModelIdPropertyName extends string = never\n> {\n  // just to make typing work properly\n  [propsTypeSymbol]!: TProps;\n  [fromSnapshotOverrideTypeSymbol]!: FromSnapshotOverride;\n  [toSnapshotOverrideTypeSymbol]!: ToSnapshotOverride;\n  [modelIdPropertyNameSymbol]!: ModelIdPropertyName;\n\n  /**\n   * Model type name.\n   */\n  readonly [modelTypeKey]!: string\n\n  /**\n   * Model internal id. Can be modified inside a model action.\n   * It will return `undefined` if there's no id prop set.\n   */\n  get [modelIdKey](): [ModelIdPropertyName] extends [never] ? never : string {\n    const idProp = getModelIdPropertyName(this.constructor as any)\n    return idProp ? this.$[idProp] : (undefined as any)\n  }\n\n  set [modelIdKey](newId: [ModelIdPropertyName] extends [never] ? never : string) {\n    const idProp = getModelIdPropertyName(this.constructor as any)\n    if (!idProp) {\n      throw failure(\"$modelId cannot be set when there is no idProp set in the model\")\n    }\n    ;(this.$ as any)[idProp] = newId\n  }\n\n  /**\n   * Can be overridden to offer a reference id to be used in reference resolution.\n   * By default it will use the `idProp` if available or return `undefined` otherwise.\n   */\n  getRefId(): string | undefined {\n    return this[modelIdKey]\n  }\n\n  /**\n   * Called after the model has been created.\n   */\n  protected onInit?(): void\n\n  /**\n   * Data part of the model, which is observable and will be serialized in snapshots.\n   * Use it if one of the data properties matches one of the model properties/functions.\n   */\n  readonly $!: ModelPropsToData<TProps>\n\n  /**\n   * Optional hook that will run once this model instance is attached to the tree of a model marked as\n   * root store via `registerRootStore`.\n   * Basically this is the place where you know the full root store is complete and where things such as\n   * middlewares, effects (reactions, etc), and other side effects should be registered, since it means\n   * that the model is now part of the active application state.\n   *\n   * It can return a disposer that will be run once this model instance is detached from such root store tree.\n   *\n   * @param rootStore\n   * @returns\n   */\n  protected onAttachedToRootStore?(rootStore: object): (() => void) | void\n\n  /**\n   * Performs a type check over the model instance.\n   * For this to work a data type has to be declared as part of the model properties.\n   *\n   * @returns A `TypeCheckError` or `null` if there is no error.\n   */\n  typeCheck(): TypeCheckError | null {\n    const type = typesModel<this>(this.constructor as any)\n    return typeCheck(type, this as any)\n  }\n\n  /**\n   * Creates an instance of a model.\n   */\n  constructor(data: ModelPropsToTransformedCreationData<TProps>) {\n    let initialData = data as any\n    const { snapshotInitialData, modelClass, generateNewIds }: ModelConstructorOptions =\n      arguments[1] as any\n\n    Object.setPrototypeOf(this, modelClass!.prototype)\n\n    const self = this as any\n\n    // delete unnecessary props\n    delete self[propsTypeSymbol]\n    delete self[fromSnapshotOverrideTypeSymbol]\n    delete self[toSnapshotOverrideTypeSymbol]\n    delete self[modelIdPropertyNameSymbol]\n\n    if (!snapshotInitialData) {\n      // plain new\n      assertIsObject(initialData, \"initialData\")\n\n      internalNewModel(this, observable.object(initialData as any, undefined, { deep: false }), {\n        modelClass,\n        generateNewIds: true,\n      })\n    } else {\n      // from snapshot\n      internalNewModel(this, undefined, { modelClass, snapshotInitialData, generateNewIds })\n    }\n  }\n\n  toString(options?: { withData?: boolean }) {\n    const finalOptions = {\n      withData: true,\n      ...options,\n    }\n\n    const firstPart = `${this.constructor.name}#${this[modelTypeKey]}`\n\n    return finalOptions.withData\n      ? `[${firstPart} ${JSON.stringify(getSnapshot(this))}]`\n      : `[${firstPart}]`\n  }\n}\n\n/**\n * @ignore\n */\nexport type BaseModelKeys = keyof AnyModel | \"onInit\" | \"onAttachedToRootStore\"\n\n// these props will never be hoisted to this (except for model id)\n/**\n * @internal\n */\nexport const baseModelPropNames = new Set<BaseModelKeys>([\n  modelTypeKey,\n  modelIdKey,\n  \"onInit\",\n  \"$\",\n  \"getRefId\",\n  \"onAttachedToRootStore\",\n  \"typeCheck\",\n])\n\n/**\n * Any kind of model instance.\n */\nexport interface AnyModel extends BaseModel<any, any, any, any> {}\n\n/**\n * @deprecated Should not be needed anymore.\n *\n * Tricks TypeScript into accepting abstract classes as a parameter for `ExtendedModel`.\n * Does nothing in runtime.\n *\n * @typeparam T Abstract model class type.\n * @param type Abstract model class.\n * @returns\n */\nexport function abstractModelClass<T>(type: T): T & Object {\n  return type as any\n}\n\n/**\n * The model id property name.\n */\nexport type ModelIdPropertyName<M extends AnyModel> = M[typeof modelIdPropertyNameSymbol]\n\n/**\n * Add missing model metadata to a model creation snapshot to generate a proper model snapshot.\n * Usually used alongside `fromSnapshot`.\n *\n * @typeparam M Model type.\n * @param modelClass Model class.\n * @param snapshot Model creation snapshot without metadata.\n * @returns The model snapshot (including metadata).\n */\nexport function modelSnapshotInWithMetadata<M extends AnyModel>(\n  modelClass: ModelClass<M>,\n  snapshot: Omit<SnapshotInOfModel<M>, typeof modelTypeKey>\n): SnapshotInOfModel<M> {\n  assertIsModelClass(modelClass, \"modelClass\")\n  assertIsObject(snapshot, \"initialData\")\n\n  const modelInfo = modelInfoByClass.get(modelClass)!\n\n  return {\n    ...snapshot,\n    [modelTypeKey]: modelInfo.name,\n  } as any\n}\n\n/**\n * Add missing model metadata to a model output snapshot to generate a proper model snapshot.\n * Usually used alongside `applySnapshot`.\n *\n * @typeparam M Model type.\n * @param modelClass Model class.\n * @param snapshot Model output snapshot without metadata.\n * @returns The model snapshot (including metadata).\n */\nexport function modelSnapshotOutWithMetadata<M extends AnyModel>(\n  modelClass: ModelClass<M>,\n  snapshot: Omit<SnapshotOutOfModel<M>, typeof modelTypeKey>\n): SnapshotOutOfModel<M> {\n  assertIsModelClass(modelClass, \"modelClass\")\n  assertIsObject(snapshot, \"initialData\")\n\n  const modelInfo = modelInfoByClass.get(modelClass)!\n\n  return {\n    ...snapshot,\n    [modelTypeKey]: modelInfo.name,\n  } as any\n}\n\n/**\n * A model class declaration, made of a base model and the model interface.\n */\nexport type ModelClassDeclaration<BaseModelClass, ModelInterface> = BaseModelClass & {\n  new (...args: any[]): ModelInterface\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4Ba,4BAA4B,OAAO,qBAAqB;MAW/C;EAiFpB,YAAY;AA1EX;AACA;AACA;AACA;AAKS;AAoCD;QA+BH,cAAc;UACZ,EAAE,qBAAqB,YAAY,mBACvC,UAAU;WAEL,eAAe,MAAM,WAAY,SAAS;UAE3C,OAAO;WAGN,KAAK;WACL,KAAK;WACL,KAAK;WACL,KAAK;QAER,CAAC,qBAAqB;qBAET,aAAa,aAAa;uBAExB,MAAM,WAAW,OAAO,aAAoB,QAAW,EAAE,MAAM,OAAO,GAAG;AAAA,QACxF;AAAA,QACA,gBAAgB;AAAA,OACjB;AAAA,WACI;uBAEY,MAAM,QAAW,EAAE,YAAY,qBAAqB,gBAAgB;AAAA;;OAnGxF,uBACA,qCACA,mCACA,gCAKS,mBAML;UACG,SAAS,uBAAuB,KAAK,WAAkB;WACtD,SAAS,KAAK,EAAE,UAAW;AAAA;OAG/B,YAAY;UACT,SAAS,uBAAuB,KAAK,WAAkB;QACzD,CAAC,QAAQ;YACL,QAAQ,iEAAiE;AAAA;SAE1E,EAAU,UAAU;AAAA;EAO7B;WACS,KAAK;AAAA;EAkCd;UACQ,OAAO,WAAiB,KAAK,WAAkB;WAC9C,UAAU,MAAM,IAAW;AAAA;EAmCpC,SAAS;UACD,eAAe;AAAA,MACnB,UAAU;AAAA,OACP;UAGC,YAAY,GAAG,KAAK,YAAY,QAAQ,KAAK;WAE5C,aAAa,WAChB,IAAI,aAAa,KAAK,UAAU,YAAY,IAAI,CAAC,OACjD,IAAI;AAAA;;MAaC,yCAAyB,IAAmB;AAAA,EACvD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;CACD;4BAiBqC;SAC7B;AACT;qCAiBE,YACA;qBAEmB,YAAY,YAAY;iBAC5B,UAAU,aAAa;QAEhC,YAAY,iBAAiB,IAAI,UAAU;SAE1C,iCACF,WADE;AAAA,KAEJ,eAAe,UAAU;AAAA;AAE9B;sCAYE,YACA;qBAEmB,YAAY,YAAY;iBAC5B,UAAU,aAAa;QAEhC,YAAY,iBAAiB,IAAI,UAAU;SAE1C,iCACF,WADE;AAAA,KAEJ,eAAe,UAAU;AAAA;AAE9B;;"}

package/dist/src/model/Model.mjs

@@ -0,0 +1,36 @@
+import { sharedInternalModel } from "../modelShared/Model.mjs";
+import { isModelClass, assertIsModelClass } from "./utils.mjs";
+function ExtendedModel(...args) {
+  let baseModel;
+  let modelProps;
+  let modelOptions;
+  if (isModelClass(args[0])) {
+    baseModel = args[0];
+    modelProps = args[1];
+    modelOptions = args[2];
+  } else {
+    const gen = args[0]();
+    baseModel = gen.baseModel;
+    modelProps = gen.props;
+    modelOptions = args[1];
+  }
+  assertIsModelClass(baseModel, "baseModel");
+  return internalModel(modelProps, baseModel, modelOptions);
+}
+function Model(fnModelPropsOrModelProps, modelOptions) {
+  const modelProps = typeof fnModelPropsOrModelProps === "function" ? fnModelPropsOrModelProps() : fnModelPropsOrModelProps;
+  return internalModel(modelProps, void 0, modelOptions);
+}
+function internalModel(modelProps, baseModel, modelOptions) {
+  var _a;
+  return sharedInternalModel({
+    modelProps,
+    baseModel,
+    type: "class",
+    valueType: (_a = modelOptions == null ? void 0 : modelOptions.valueType) != null ? _a : false,
+    fromSnapshotProcessor: modelOptions == null ? void 0 : modelOptions.fromSnapshotProcessor,
+    toSnapshotProcessor: modelOptions == null ? void 0 : modelOptions.toSnapshotProcessor
+  });
+}
+export { ExtendedModel, Model };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"Model.mjs","sources":["../../../src/model/Model.ts"],"sourcesContent":["import type {\n  AbstractModelClass,\n  ModelClass,\n  ModelTransformedCreationData,\n} from \"../modelShared/BaseModelShared\"\nimport { sharedInternalModel } from \"../modelShared/Model\"\nimport type {\n  ModelProps,\n  ModelPropsToSetter,\n  ModelPropsToSnapshotCreationData,\n  ModelPropsToSnapshotData,\n  ModelPropsToTransformedCreationData,\n  ModelPropsToTransformedData,\n} from \"../modelShared/prop\"\nimport type { AnyModel, BaseModel, BaseModelKeys, ModelIdPropertyName } from \"./BaseModel\"\nimport { assertIsModelClass, isModelClass } from \"./utils\"\n\nexport type _ComposedCreationData<\n  SuperModel,\n  TProps extends ModelProps\n> = SuperModel extends AnyModel\n  ? ModelPropsToTransformedCreationData<TProps> & ModelTransformedCreationData<SuperModel>\n  : ModelPropsToTransformedCreationData<TProps>\n\n/**\n * The default type used by fromSnapshot before processors are applied.\n */\nexport type FromSnapshotDefaultType<TProps extends ModelProps> =\n  ModelPropsToSnapshotCreationData<TProps>\n\n/**\n * The default type used by getSnapshot before processors are applied.\n */\nexport type ToSnapshotDefaultType<TProps extends ModelProps> = ModelPropsToSnapshotData<TProps>\n\nexport type _ModelId<SuperModel, TProps extends ModelProps> = SuperModel extends AnyModel\n  ? ModelIdPropertyName<SuperModel>\n  : ExtractModelIdProp<TProps> & string\n\nexport interface _Model<\n  SuperModel,\n  TProps extends ModelProps,\n  FromSnapshotOverride extends Record<string, any>,\n  ToSnapshotOverride extends Record<string, any>\n> {\n  new (data: _ComposedCreationData<SuperModel, TProps>): SuperModel &\n    BaseModel<TProps, FromSnapshotOverride, ToSnapshotOverride, _ModelId<SuperModel, TProps>> &\n    Omit<ModelPropsToTransformedData<TProps>, BaseModelKeys> &\n    ModelPropsToSetter<TProps>\n}\n\n/**\n * Extract the model id property from the model props.\n */\nexport type ExtractModelIdProp<TProps extends ModelProps> = {\n  [K in keyof TProps]: TProps[K][\"_internal\"][\"$isId\"] extends true ? K : never\n}[keyof TProps]\n\n/**\n * Base abstract class for models that extends another model.\n *\n * @typeparam TProps New model properties type.\n * @typeparam TModelClass Model class type.\n * @param genFn Function that returns the base model and model properties.\n * @param modelOptions Model options.\n * @returns\n */\nexport function ExtendedModel<\n  TProps extends ModelProps,\n  TModelClass extends AbstractModelClass<AnyModel>,\n  A extends [],\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(\n  genFn: (...args: A) => {\n    baseModel: TModelClass\n    props: TProps\n  },\n  modelOptions?: ModelOptions<TProps, FS, TS>\n): _Model<InstanceType<TModelClass>, TProps, FS, TS>\n\n/**\n * Base abstract class for models that extends another model.\n *\n * @typeparam TProps New model properties type.\n * @typeparam TModelClass Model class type.\n * @param baseModel Base model type.\n * @param modelProps Model properties.\n * @param modelOptions Model options.\n * @returns\n */\nexport function ExtendedModel<\n  TProps extends ModelProps,\n  TModelClass extends AbstractModelClass<AnyModel>,\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(\n  baseModel: TModelClass,\n  modelProps: TProps,\n  modelOptions?: ModelOptions<TProps, FS, TS>\n): _Model<InstanceType<TModelClass>, TProps, FS, TS> & {\n  [P in Exclude<keyof TModelClass, \"prototype\">]: TModelClass[P]\n}\n\n// base\nexport function ExtendedModel<\n  TProps extends ModelProps,\n  TModelClass extends AbstractModelClass<AnyModel>,\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(...args: any[]): _Model<InstanceType<TModelClass>, TProps, FS, TS> {\n  let baseModel\n  let modelProps\n  let modelOptions\n  if (isModelClass(args[0])) {\n    baseModel = args[0]\n    modelProps = args[1]\n    modelOptions = args[2]\n  } else {\n    const gen = args[0]()\n\n    baseModel = gen.baseModel\n    modelProps = gen.props\n    modelOptions = args[1]\n  }\n\n  assertIsModelClass(baseModel, \"baseModel\")\n\n  return internalModel(modelProps, baseModel as any, modelOptions)\n}\n\n/**\n * Base abstract class for models.\n *\n * Never override the constructor, use `onInit` or `onAttachedToRootStore` instead.\n *\n * @typeparam TProps Model properties type.\n * @param fnModelProps Function that generates model properties.\n * @param modelOptions Model options.\n */\nexport function Model<\n  TProps extends ModelProps,\n  A extends [],\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(\n  fnModelProps: (...args: A) => TProps,\n  modelOptions?: ModelOptions<TProps, FS, TS>\n): _Model<unknown, TProps, FS, TS>\n\n/**\n * Base abstract class for models.\n *\n * Never override the constructor, use `onInit` or `onAttachedToRootStore` instead.\n *\n * @typeparam TProps Model properties type.\n * @param modelProps Model properties.\n * @param modelOptions Model options.\n */\nexport function Model<\n  TProps extends ModelProps,\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(modelProps: TProps, modelOptions?: ModelOptions<TProps, FS, TS>): _Model<unknown, TProps, FS, TS>\n\n// base\nexport function Model<\n  TProps extends ModelProps,\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(\n  fnModelPropsOrModelProps: (() => TProps) | TProps,\n  modelOptions?: ModelOptions<TProps, FS, TS>\n): _Model<unknown, TProps, FS, TS> {\n  const modelProps =\n    typeof fnModelPropsOrModelProps === \"function\"\n      ? fnModelPropsOrModelProps()\n      : fnModelPropsOrModelProps\n  return internalModel(modelProps, undefined, modelOptions)\n}\n\nfunction internalModel<\n  TProps extends ModelProps,\n  TBaseModel extends AnyModel,\n  FS extends Record<string, any> = never,\n  TS extends Record<string, any> = never\n>(\n  modelProps: TProps,\n  baseModel: ModelClass<TBaseModel> | undefined,\n  modelOptions?: ModelOptions<TProps, FS, TS>\n): _Model<TBaseModel, TProps, FS, TS> {\n  return sharedInternalModel({\n    modelProps,\n    baseModel,\n    type: \"class\",\n    valueType: modelOptions?.valueType ?? false,\n    fromSnapshotProcessor: modelOptions?.fromSnapshotProcessor,\n    toSnapshotProcessor: modelOptions?.toSnapshotProcessor,\n  })\n}\n\n/**\n * Model options.\n */\nexport interface ModelOptions<TProps extends ModelProps, FS, TS> {\n  /**\n   * A value type will be cloned automatically when being attached to a new tree.\n   * The default is `false`.\n   */\n  valueType?: boolean\n\n  /**\n   * Optional transformation that will be run when converting from a snapshot to the data part of the model.\n   * Useful for example to do versioning and keep the data part up to date with the latest version of the model.\n   *\n   * @param sn The custom input snapshot.\n   * @returns An input snapshot that must match the expected model input snapshot.\n   */\n  fromSnapshotProcessor?(sn: FS): FromSnapshotDefaultType<TProps>\n\n  /**\n   * Optional transformation that will be run when converting the data part of the model into a snapshot.\n   *\n   * @param sn The output snapshot.\n   * @param modelInstance The model instance.\n   * @returns  a custom output snapshot.\n   */\n  toSnapshotProcessor?(sn: ToSnapshotDefaultType<TProps>, modelInstance: any): TS\n}\n"],"names":[],"mappings":";;0BA8GK;MACC;MACA;MACA;MACA,aAAa,KAAK,EAAE,GAAG;gBACb,KAAK;iBACJ,KAAK;mBACH,KAAK;AAAA,SACf;UACC,MAAM,KAAK;gBAEL,IAAI;iBACH,IAAI;mBACF,KAAK;AAAA;qBAGH,WAAW,WAAW;SAElC,cAAc,YAAY,WAAkB,YAAY;AACjE;eA0CE,0BACA;QAEM,aACJ,OAAO,6BAA6B,aAChC,6BACA;SACC,cAAc,YAAY,QAAW,YAAY;AAC1D;AAEA,uBAME,YACA,WACA;;SAEO,oBAAoB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,WAAW,mDAAc,cAAd,YAA2B;AAAA,IACtC,uBAAuB,6CAAc;AAAA,IACrC,qBAAqB,6CAAc;AAAA,GACpC;AACH;;"}

package/dist/src/model/getModelMetadata.mjs

@@ -0,0 +1,19 @@
+import { modelMetadataSymbol } from "../modelShared/modelSymbols.mjs";
+import { failure } from "../utils/index.mjs";
+import { getOrCreate } from "../utils/mapUtils.mjs";
+import { isModel, isModelClass } from "./utils.mjs";
+function getModelMetadata(modelClassOrInstance) {
+  if (isModel(modelClassOrInstance)) {
+    return modelClassOrInstance.constructor[modelMetadataSymbol];
+  } else if (isModelClass(modelClassOrInstance)) {
+    return modelClassOrInstance[modelMetadataSymbol];
+  } else {
+    throw failure(`modelClassOrInstance must be a model class or instance`);
+  }
+}
+const modelIdPropertyNameCache = /* @__PURE__ */ new WeakMap();
+function getModelIdPropertyName(modelClass) {
+  return getOrCreate(modelIdPropertyNameCache, modelClass, () => getModelMetadata(modelClass).modelIdProperty);
+}
+export { getModelIdPropertyName, getModelMetadata };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/model/metadata.mjs

@@ -0,0 +1,7 @@
+const modelTypeKey = "$modelType";
+const modelIdKey = "$modelId";
+function isReservedModelKey(key) {
+  return key === modelTypeKey;
+}
+export { isReservedModelKey, modelIdKey, modelTypeKey };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvbWV0YWRhdGEudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBLZXkgd2hlcmUgbW9kZWwgc25hcHNob3RzIHdpbGwgc3RvcmUgbW9kZWwgdHlwZSBtZXRhZGF0YS5cbiAqL1xuZXhwb3J0IGNvbnN0IG1vZGVsVHlwZUtleSA9IFwiJG1vZGVsVHlwZVwiXG5cbi8qKlxuICogS2V5IHRoYXQgc2VydmVzIGFzIHByb3h5IHRvIHRoZSBtb2RlbCBwcm9wZXJ0eSBkZXNpZ25lZCBhcyAnaWRQcm9wJyAoaWYgYW55KS5cbiAqL1xuZXhwb3J0IGNvbnN0IG1vZGVsSWRLZXkgPSBcIiRtb2RlbElkXCJcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqIFJldHVybnMgaWYgYSBnaXZlbiBrZXkgaXMgYSByZXNlcnZlZCBrZXkgaW4gbW9kZWwgc25hcHNob3RzLlxuICpcbiAqIEBwYXJhbSBrZXlcbiAqIEByZXR1cm5zXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc1Jlc2VydmVkTW9kZWxLZXkoa2V5OiBzdHJpbmcpIHtcbiAgLy8gbm90ZSAkbW9kZWxJZCBpcyBOT1QgYSByZXNlcnZlZCBrZXksIHNpbmNlIGl0IHdpbGwgZXZlbnR1YWxseSBlbmQgdXAgaW4gdGhlIGRhdGFcbiAgLy8gYW5kIGNhbiBhY3R1YWxseSBiZSBjaGFuZ2VkXG4gIHJldHVybiBrZXkgPT09IG1vZGVsVHlwZUtleVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJNQUdhLGVBQWU7TUFLZixhQUFhOzRCQVNTO1NBRzFCLFFBQVE7QUFDakI7OyJ9

package/dist/src/model/newModel.mjs

@@ -0,0 +1,95 @@
+import { action, set } from "mobx";
+import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig.mjs";
+import { modelInfoByClass } from "../modelShared/modelInfo.mjs";
+import { getInternalModelClassPropsInfo } from "../modelShared/modelPropsInfo.mjs";
+import { applyModelInitializers } from "../modelShared/newModel.mjs";
+import { noDefaultValue } from "../modelShared/prop.mjs";
+import { tweakModel } from "../tweaker/tweakModel.mjs";
+import { tweakPlainObject } from "../tweaker/tweakPlainObject.mjs";
+import { failure } from "../utils/index.mjs";
+import { getModelIdPropertyName, getModelMetadata } from "./getModelMetadata.mjs";
+import { modelTypeKey } from "./metadata.mjs";
+import "../types/TypeChecker.mjs";
+import "../types/primitiveBased/primitives.mjs";
+import "../snapshot/internal.mjs";
+const internalNewModel = action("newModel", (origModelObj, initialData, options) => {
+  const mode = initialData ? "new" : "fromSnapshot";
+  const { modelClass: _modelClass, snapshotInitialData, generateNewIds } = options;
+  const modelClass = _modelClass;
+  const modelObj = origModelObj;
+  const modelInfo = modelInfoByClass.get(modelClass);
+  if (!modelInfo) {
+    throw failure(`no model info for class ${modelClass.name} could be found - did you forget to add the @model decorator?`);
+  }
+  const modelIdPropertyName = getModelIdPropertyName(modelClass);
+  const modelProps = getInternalModelClassPropsInfo(modelClass);
+  const modelIdPropData = modelIdPropertyName ? modelProps[modelIdPropertyName] : void 0;
+  let id;
+  if (snapshotInitialData) {
+    let sn = snapshotInitialData.unprocessedSnapshot;
+    if (modelIdPropData && modelIdPropertyName) {
+      if (generateNewIds) {
+        id = modelIdPropData._internal.defaultFn();
+      } else {
+        id = sn[modelIdPropertyName];
+      }
+    }
+    if (modelClass.fromSnapshotProcessor) {
+      sn = modelClass.fromSnapshotProcessor(sn);
+    }
+    initialData = snapshotInitialData.snapshotToInitialData(sn);
+  } else {
+    if (modelIdPropData && modelIdPropertyName) {
+      if (initialData[modelIdPropertyName]) {
+        id = initialData[modelIdPropertyName];
+      } else {
+        id = modelIdPropData._internal.defaultFn();
+      }
+    }
+  }
+  modelObj[modelTypeKey] = modelInfo.name;
+  const modelPropsKeys = Object.keys(modelProps);
+  for (let i = 0; i < modelPropsKeys.length; i++) {
+    const k = modelPropsKeys[i];
+    if (k === modelIdPropertyName) {
+      continue;
+    }
+    const propData = modelProps[k];
+    let newValue = initialData[k];
+    let changed = false;
+    if (mode === "new" && propData._internal.transform) {
+      changed = true;
+      newValue = propData._internal.transform.untransform(newValue, modelObj, k);
+    }
+    if (newValue == null) {
+      if (propData._internal.defaultFn !== noDefaultValue) {
+        changed = true;
+        newValue = propData._internal.defaultFn();
+      } else if (propData._internal.defaultValue !== noDefaultValue) {
+        changed = true;
+        newValue = propData._internal.defaultValue;
+      } else if (!("k" in initialData)) {
+        changed = true;
+      }
+    }
+    if (changed) {
+      set(initialData, k, newValue);
+    }
+  }
+  if (modelIdPropertyName) {
+    set(initialData, modelIdPropertyName, id);
+  }
+  tweakModel(modelObj, void 0);
+  let obsData = tweakPlainObject(initialData, { parent: modelObj, path: "$" }, modelObj[modelTypeKey], false, true);
+  modelObj.$ = obsData;
+  if (isModelAutoTypeCheckingEnabled() && getModelMetadata(modelClass).dataType) {
+    const err = modelObj.typeCheck();
+    if (err) {
+      err.throw(modelObj);
+    }
+  }
+  applyModelInitializers(modelClass, modelObj);
+  return modelObj;
+});
+export { internalNewModel };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"newModel.mjs","sources":["../../../src/model/newModel.ts"],"sourcesContent":["import { action, set } from \"mobx\"\nimport type { O } from \"ts-toolbelt\"\nimport { isModelAutoTypeCheckingEnabled } from \"../globalConfig/globalConfig\"\nimport type { ModelTransformedCreationData } from \"../modelShared/BaseModelShared\"\nimport { modelInfoByClass } from \"../modelShared/modelInfo\"\nimport { getInternalModelClassPropsInfo } from \"../modelShared/modelPropsInfo\"\nimport { applyModelInitializers } from \"../modelShared/newModel\"\nimport { noDefaultValue } from \"../modelShared/prop\"\nimport { tweakModel } from \"../tweaker/tweakModel\"\nimport { tweakPlainObject } from \"../tweaker/tweakPlainObject\"\nimport { failure, inDevMode, makePropReadonly } from \"../utils\"\nimport type { AnyModel } from \"./BaseModel\"\nimport { getModelIdPropertyName, getModelMetadata } from \"./getModelMetadata\"\nimport { modelTypeKey } from \"./metadata\"\nimport type { ModelConstructorOptions } from \"./ModelConstructorOptions\"\nimport { assertIsModelClass } from \"./utils\"\n\n/**\n * @internal\n */\nexport const internalNewModel = action(\n  \"newModel\",\n  <M extends AnyModel>(\n    origModelObj: M,\n    initialData: ModelTransformedCreationData<M> | undefined,\n    options: Pick<ModelConstructorOptions, \"modelClass\" | \"snapshotInitialData\" | \"generateNewIds\">\n  ): M => {\n    const mode = initialData ? \"new\" : \"fromSnapshot\"\n    const { modelClass: _modelClass, snapshotInitialData, generateNewIds } = options\n    const modelClass = _modelClass!\n\n    if (inDevMode()) {\n      assertIsModelClass(modelClass, \"modelClass\")\n    }\n\n    const modelObj = origModelObj as O.Writable<M>\n\n    const modelInfo = modelInfoByClass.get(modelClass)\n    if (!modelInfo) {\n      throw failure(\n        `no model info for class ${modelClass.name} could be found - did you forget to add the @model decorator?`\n      )\n    }\n\n    const modelIdPropertyName = getModelIdPropertyName(modelClass)\n    const modelProps = getInternalModelClassPropsInfo(modelClass)\n    const modelIdPropData = modelIdPropertyName ? modelProps[modelIdPropertyName]! : undefined\n\n    let id: string | undefined\n    if (snapshotInitialData) {\n      let sn = snapshotInitialData.unprocessedSnapshot\n\n      if (modelIdPropData && modelIdPropertyName) {\n        if (generateNewIds) {\n          id = (modelIdPropData._internal.defaultFn as () => string)()\n        } else {\n          id = sn[modelIdPropertyName]\n        }\n      }\n\n      if (modelClass.fromSnapshotProcessor) {\n        sn = modelClass.fromSnapshotProcessor(sn)\n      }\n\n      initialData = snapshotInitialData.snapshotToInitialData(sn)\n    } else {\n      // use symbol if provided\n      if (modelIdPropData && modelIdPropertyName) {\n        if (initialData![modelIdPropertyName]) {\n          id = initialData![modelIdPropertyName]\n        } else {\n          id = (modelIdPropData._internal.defaultFn as () => string)()\n        }\n      }\n    }\n\n    modelObj[modelTypeKey] = modelInfo.name\n\n    // fill in defaults in initial data\n    const modelPropsKeys = Object.keys(modelProps)\n    for (let i = 0; i < modelPropsKeys.length; i++) {\n      const k = modelPropsKeys[i]\n\n      // id is already initialized above\n      if (k === modelIdPropertyName) {\n        continue\n      }\n\n      const propData = modelProps[k]\n\n      let newValue = initialData![k]\n      let changed = false\n\n      // apply untransform (if any)\n      if (mode === \"new\" && propData._internal.transform) {\n        changed = true\n        newValue = propData._internal.transform.untransform(newValue, modelObj, k)\n      }\n\n      // apply default value (if needed)\n      if (newValue == null) {\n        if (propData._internal.defaultFn !== noDefaultValue) {\n          changed = true\n          newValue = propData._internal.defaultFn()\n        } else if (propData._internal.defaultValue !== noDefaultValue) {\n          changed = true\n          newValue = propData._internal.defaultValue\n        } else if (!(\"k\" in initialData!)) {\n          // for mobx4, we need to set up properties even if they are undefined\n          changed = true\n        }\n      }\n\n      if (changed) {\n        set(initialData as any, k, newValue)\n      }\n    }\n\n    if (modelIdPropertyName) {\n      set(initialData as any, modelIdPropertyName, id)\n    }\n\n    tweakModel(modelObj, undefined)\n\n    // create observable data object with initial data\n    let obsData = tweakPlainObject(\n      initialData!,\n      { parent: modelObj, path: \"$\" },\n      modelObj[modelTypeKey],\n      false,\n      true\n    )\n\n    // link it, and make it readonly\n    modelObj.$ = obsData\n    if (inDevMode()) {\n      makePropReadonly(modelObj, \"$\", true)\n    }\n\n    // type check it if needed\n    if (isModelAutoTypeCheckingEnabled() && getModelMetadata(modelClass).dataType) {\n      const err = modelObj.typeCheck()\n      if (err) {\n        err.throw(modelObj)\n      }\n    }\n\n    // run any extra initializers for the class as needed\n    applyModelInitializers(modelClass, modelObj)\n\n    return modelObj as M\n  }\n)\n"],"names":[],"mappings":";;;;;;;;;;;;;;MAoBa,mBAAmB,OAC9B,YACA,CACE,cACA,aACA;QAEM,OAAO,cAAc,QAAQ;QAC7B,EAAE,YAAY,aAAa,qBAAqB,mBAAmB;QACnE,aAAa;QAMb,WAAW;QAEX,YAAY,iBAAiB,IAAI,UAAU;MAC7C,CAAC,WAAW;UACR,QACJ,2BAA2B,WAAW,mEAAmE;AAAA;QAIvG,sBAAsB,uBAAuB,UAAU;QACvD,aAAa,+BAA+B,UAAU;QACtD,kBAAkB,sBAAsB,WAAW,uBAAwB;MAE7E;MACA,qBAAqB;QACnB,KAAK,oBAAoB;QAEzB,mBAAmB,qBAAqB;UACtC,gBAAgB;aACZ,gBAAgB,UAAU;aAC3B;aACA,GAAG;AAAA;;QAIR,WAAW,uBAAuB;WAC/B,WAAW,sBAAsB,EAAE;AAAA;kBAG5B,oBAAoB,sBAAsB,EAAE;AAAA,SACrD;QAED,mBAAmB,qBAAqB;UACtC,YAAa,sBAAsB;aAChC,YAAa;AAAA,aACb;aACC,gBAAgB,UAAU;;;;WAK7B,gBAAgB,UAAU;QAG7B,iBAAiB,OAAO,KAAK,UAAU;WACpC,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;UACxC,IAAI,eAAe;QAGrB,MAAM,qBAAqB;;;UAIzB,WAAW,WAAW;QAExB,WAAW,YAAa;QACxB,UAAU;QAGV,SAAS,SAAS,SAAS,UAAU,WAAW;gBACxC;iBACC,SAAS,UAAU,UAAU,YAAY,UAAU,UAAU,CAAC;AAAA;QAIvE,YAAY,MAAM;UAChB,SAAS,UAAU,cAAc,gBAAgB;kBACzC;mBACC,SAAS,UAAU;iBACrB,SAAS,UAAU,iBAAiB,gBAAgB;kBACnD;mBACC,SAAS,UAAU;AAAA,iBACrB,SAAS,cAAe;kBAEvB;AAAA;;QAIV,SAAS;UACP,aAAoB,GAAG,QAAQ;AAAA;;MAInC,qBAAqB;QACnB,aAAoB,qBAAqB,EAAE;AAAA;aAGtC,UAAU,MAAS;MAG1B,UAAU,iBACZ,aACA,EAAE,QAAQ,UAAU,MAAM,OAC1B,SAAS,eACT,OACA,IAAI;WAIG,IAAI;MAMT,oCAAoC,iBAAiB,UAAU,EAAE,UAAU;UACvE,MAAM,SAAS;QACjB,KAAK;UACH,MAAM,QAAQ;AAAA;;yBAKC,YAAY,QAAQ;SAEpC;AACT,CAAC;;"}

package/dist/src/model/utils.mjs

@@ -0,0 +1,33 @@
+import { isPlainObject, failure } from "../utils/index.mjs";
+import { BaseModel } from "./BaseModel.mjs";
+import { modelTypeKey } from "./metadata.mjs";
+function isModel(model) {
+  return model instanceof BaseModel;
+}
+function assertIsModel(model, argName, customErrMsg = "must be a model instance") {
+  if (!isModel(model)) {
+    throw failure(`${argName} ${customErrMsg}`);
+  }
+}
+function isModelClass(modelClass) {
+  if (typeof modelClass !== "function") {
+    return false;
+  }
+  if (modelClass !== BaseModel && !(modelClass.prototype instanceof BaseModel)) {
+    return false;
+  }
+  return true;
+}
+function assertIsModelClass(modelClass, argName) {
+  if (typeof modelClass !== "function") {
+    throw failure(`${argName} must be a class`);
+  }
+  if (modelClass !== BaseModel && !(modelClass.prototype instanceof BaseModel)) {
+    throw failure(`${argName} must extend Model`);
+  }
+}
+function isModelSnapshot(sn) {
+  return isPlainObject(sn) && modelTypeKey in sn;
+}
+export { assertIsModel, assertIsModelClass, isModel, isModelClass, isModelSnapshot };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/modelShared/BaseModelShared.mjs

@@ -0,0 +1,9 @@
+const propsTypeSymbol = Symbol("propsType");
+const fromSnapshotOverrideTypeSymbol = Symbol("fromSnapshotOverrideType");
+const toSnapshotOverrideTypeSymbol = Symbol("toSnapshotOverrideType");
+const modelInitializedSymbol = Symbol("modelInitialized");
+function modelClass(type) {
+  return type;
+}
+export { fromSnapshotOverrideTypeSymbol, modelClass, modelInitializedSymbol, propsTypeSymbol, toSnapshotOverrideTypeSymbol };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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