mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/types/utility/or.mjs

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { lazy, failure } from "../../utils/index.mjs";
+import { getTypeInfo } from "../getTypeInfo.mjs";
+import { resolveStandardTypeNoThrow, resolveTypeChecker, resolveStandardType } from "../resolveTypeChecker.mjs";
+import { TypeInfo, lateTypeChecker, TypeChecker, getTypeCheckerBaseTypeFromValue, TypeCheckerBaseType } from "../TypeChecker.mjs";
+import { TypeCheckError } from "../TypeCheckError.mjs";
+import { typesUnchecked } from "./unchecked.mjs";
+function typesOr(dispatcherOrType, ...moreOrTypes) {
+  const orTypes = moreOrTypes.slice();
+  let finalDispatcher;
+  const firstTypeChecker = resolveStandardTypeNoThrow(dispatcherOrType);
+  if (firstTypeChecker) {
+    orTypes.unshift(firstTypeChecker);
+  } else {
+    const dispatcher = dispatcherOrType;
+    finalDispatcher = (sn) => {
+      const type = dispatcher(sn);
+      const typeChecker = resolveTypeChecker(type);
+      return typeChecker;
+    };
+  }
+  if (orTypes.length <= 0) {
+    throw failure("or type must have at least 1 possible type");
+  }
+  const typeInfoGen = (t) => new OrTypeInfo(t, orTypes.map(resolveStandardType));
+  return lateTypeChecker(() => {
+    const checkers = orTypes.map(resolveTypeChecker);
+    if (checkers.some((tc) => tc.unchecked)) {
+      return typesUnchecked();
+    }
+    const getTypeName = (...recursiveTypeCheckers) => {
+      const typeNames = checkers.map((tc) => {
+        if (recursiveTypeCheckers.includes(tc)) {
+          return "...";
+        }
+        return tc.getTypeName(...recursiveTypeCheckers, tc);
+      });
+      return typeNames.join(" | ");
+    };
+    let thisTcBaseType;
+    if (checkers.some((c) => c.baseType !== checkers[0].baseType)) {
+      thisTcBaseType = TypeCheckerBaseType.Any;
+    } else {
+      thisTcBaseType = checkers[0].baseType;
+    }
+    const thisTc = new TypeChecker(thisTcBaseType, (value, path) => {
+      const someMatchingType = checkers.some((tc) => !tc.check(value, path));
+      if (someMatchingType) {
+        return null;
+      } else {
+        return new TypeCheckError(path, getTypeName(thisTc), value);
+      }
+    }, getTypeName, typeInfoGen, (value) => {
+      const valueBaseType = getTypeCheckerBaseTypeFromValue(value);
+      const checkerForBaseType = checkers.filter((c) => c.baseType === valueBaseType || c.baseType === TypeCheckerBaseType.Any);
+      if (checkerForBaseType.length === 1 && checkerForBaseType[0].baseType === valueBaseType) {
+        return checkerForBaseType[0];
+      }
+      for (let i = 0; i < checkerForBaseType.length; i++) {
+        const matchingType = checkerForBaseType[i].snapshotType(value);
+        if (matchingType) {
+          return matchingType;
+        }
+      }
+      return null;
+    }, (sn) => {
+      const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn);
+      if (!type) {
+        throw failure(`snapshot '${JSON.stringify(sn)}' does not match the following type: ${getTypeName(thisTc)}`);
+      }
+      return type.fromSnapshotProcessor(sn);
+    }, (sn) => {
+      const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn);
+      if (!type) {
+        throw failure(`snapshot '${JSON.stringify(sn)}' does not match the following type: ${getTypeName(thisTc)}`);
+      }
+      return type.toSnapshotProcessor(sn);
+    });
+    return thisTc;
+  }, typeInfoGen);
+}
+class OrTypeInfo extends TypeInfo {
+  constructor(thisType, orTypes) {
+    super(thisType);
+    __publicField(this, "orTypes");
+    __publicField(this, "_orTypeInfos", lazy(() => this.orTypes.map(getTypeInfo)));
+    this.orTypes = orTypes;
+  }
+  get orTypeInfos() {
+    return this._orTypeInfos();
+  }
+}
+export { OrTypeInfo, typesOr };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"or.mjs","sources":["../../../../src/types/utility/or.ts"],"sourcesContent":["import { failure, lazy } from \"../../utils\"\nimport { getTypeInfo } from \"../getTypeInfo\"\nimport {\n  resolveStandardType,\n  resolveStandardTypeNoThrow,\n  resolveTypeChecker,\n} from \"../resolveTypeChecker\"\nimport type { AnyStandardType, AnyType } from \"../schemas\"\nimport {\n  getTypeCheckerBaseTypeFromValue,\n  lateTypeChecker,\n  TypeChecker,\n  TypeCheckerBaseType,\n  TypeInfo,\n  TypeInfoGen,\n} from \"../TypeChecker\"\nimport { TypeCheckError } from \"../TypeCheckError\"\nimport { typesUnchecked } from \"./unchecked\"\n\n/**\n * A type that represents the union of several other types (a | b | c | ...).\n * Accepts a dispatcher that, given a snapshot, returns the type\n * that snapshot is.\n *\n * @typeparam T Type.\n * @param dispatcher Function that given a snapshot returns the type.\n * @param orTypes Possible types.\n * @returns\n */\nexport function typesOr<T extends AnyType[]>(\n  dispatcher: (sn: any) => T[number],\n  ...orTypes: T\n): T[number]\n\n/**\n * A type that represents the union of several other types (a | b | c | ...).\n *\n * Example:\n * ```ts\n * const booleanOrNumberType = types.or(types.boolean, types.number)\n * ```\n *\n * @typeparam T Type.\n * @param orTypes Possible types.\n * @returns\n */\nexport function typesOr<T extends AnyType[]>(...orTypes: T): T[number]\n\nexport function typesOr(\n  dispatcherOrType: ((sn: any) => AnyType) | AnyType,\n  ...moreOrTypes: AnyType[]\n): AnyType {\n  const orTypes = moreOrTypes.slice()\n  let finalDispatcher: ((sn: any) => TypeChecker) | undefined\n\n  const firstTypeChecker = resolveStandardTypeNoThrow(dispatcherOrType as AnyType)\n\n  if (firstTypeChecker) {\n    orTypes.unshift(firstTypeChecker)\n  } else {\n    const dispatcher = dispatcherOrType as (sn: any) => AnyType\n    finalDispatcher = (sn: any) => {\n      const type = dispatcher(sn)\n      const typeChecker = resolveTypeChecker(type)\n      return typeChecker\n    }\n  }\n\n  if (orTypes.length <= 0) {\n    throw failure(\"or type must have at least 1 possible type\")\n  }\n\n  const typeInfoGen: TypeInfoGen = (t) => new OrTypeInfo(t, orTypes.map(resolveStandardType))\n\n  return lateTypeChecker(() => {\n    const checkers = orTypes.map(resolveTypeChecker)\n\n    // if the or includes unchecked then it is unchecked\n    if (checkers.some((tc) => tc.unchecked)) {\n      return typesUnchecked() as any\n    }\n\n    const getTypeName = (...recursiveTypeCheckers: TypeChecker[]) => {\n      const typeNames = checkers.map((tc) => {\n        if (recursiveTypeCheckers.includes(tc)) {\n          return \"...\"\n        }\n        return tc.getTypeName(...recursiveTypeCheckers, tc)\n      })\n\n      return typeNames.join(\" | \")\n    }\n\n    let thisTcBaseType: TypeCheckerBaseType\n    if (checkers.some((c) => c.baseType !== checkers[0].baseType)) {\n      thisTcBaseType = TypeCheckerBaseType.Any\n    } else {\n      thisTcBaseType = checkers[0].baseType\n    }\n\n    const thisTc: TypeChecker = new TypeChecker(\n      thisTcBaseType,\n\n      (value, path) => {\n        const someMatchingType = checkers.some((tc) => !tc.check(value, path))\n        if (someMatchingType) {\n          return null\n        } else {\n          return new TypeCheckError(path, getTypeName(thisTc), value)\n        }\n      },\n\n      getTypeName,\n      typeInfoGen,\n\n      (value) => {\n        const valueBaseType = getTypeCheckerBaseTypeFromValue(value)\n\n        const checkerForBaseType = checkers.filter(\n          (c) => c.baseType === valueBaseType || c.baseType === TypeCheckerBaseType.Any\n        )\n\n        if (checkerForBaseType.length === 1 && checkerForBaseType[0].baseType === valueBaseType) {\n          // when there is only one valid option accept it without asking\n          // this is done because:\n          // 1) performance (avoid checking structure if not needed)\n          // 2) so we can accept untyped models when paired with undefined | null\n          return checkerForBaseType[0]\n        }\n\n        for (let i = 0; i < checkerForBaseType.length; i++) {\n          const matchingType = checkerForBaseType[i].snapshotType(value)\n          if (matchingType) {\n            return matchingType\n          }\n        }\n\n        return null\n      },\n\n      (sn) => {\n        const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn)\n        if (!type) {\n          throw failure(\n            `snapshot '${JSON.stringify(sn)}' does not match the following type: ${getTypeName(\n              thisTc\n            )}`\n          )\n        }\n\n        return type.fromSnapshotProcessor(sn)\n      },\n\n      (sn) => {\n        const type = finalDispatcher ? finalDispatcher(sn) : thisTc.snapshotType(sn)\n        if (!type) {\n          throw failure(\n            `snapshot '${JSON.stringify(sn)}' does not match the following type: ${getTypeName(\n              thisTc\n            )}`\n          )\n        }\n\n        return type.toSnapshotProcessor(sn)\n      }\n    )\n\n    return thisTc\n  }, typeInfoGen) as any\n}\n\n/**\n * `types.or` type info.\n */\nexport class OrTypeInfo extends TypeInfo {\n  // memoize to always return the same array on the getter\n  private _orTypeInfos = lazy(() => this.orTypes.map(getTypeInfo))\n\n  get orTypeInfos(): ReadonlyArray<TypeInfo> {\n    return this._orTypeInfos()\n  }\n\n  constructor(thisType: AnyStandardType, readonly orTypes: ReadonlyArray<AnyStandardType>) {\n    super(thisType)\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;iBAiDE,qBACG;QAEG,UAAU,YAAY;MACxB;QAEE,mBAAmB,2BAA2B,gBAA2B;MAE3E,kBAAkB;YACZ,QAAQ,gBAAgB;AAAA,SAC3B;UACC,aAAa;sBACD,CAAC;YACX,OAAO,WAAW,EAAE;YACpB,cAAc,mBAAmB,IAAI;aACpC;AAAA;;MAIP,QAAQ,UAAU,GAAG;UACjB,QAAQ,4CAA4C;AAAA;QAGtD,cAA2B,CAAC,MAAM,IAAI,WAAW,GAAG,QAAQ,IAAI,mBAAmB,CAAC;SAEnF,gBAAgB;UACf,WAAW,QAAQ,IAAI,kBAAkB;QAG3C,SAAS,KAAK,CAAC,OAAO,GAAG,SAAS,GAAG;aAChC;;UAGH,cAAc,IAAI;YAChB,YAAY,SAAS,IAAI,CAAC;YAC1B,sBAAsB,SAAS,EAAE,GAAG;iBAC/B;AAAA;eAEF,GAAG,YAAY,GAAG,uBAAuB,EAAE;AAAA,OACnD;aAEM,UAAU,KAAK,KAAK;AAAA;QAGzB;QACA,SAAS,KAAK,CAAC,MAAM,EAAE,aAAa,SAAS,GAAG,QAAQ,GAAG;uBAC5C,oBAAoB;AAAA,WAChC;uBACY,SAAS,GAAG;AAAA;UAGzB,SAAsB,IAAI,YAC9B,gBAEA,CAAC,OAAO;YACA,mBAAmB,SAAS,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,OAAO,IAAI,CAAC;UACjE,kBAAkB;eACb;AAAA,aACF;eACE,IAAI,eAAe,MAAM,YAAY,MAAM,GAAG,KAAK;AAAA;OAI9D,aACA,aAEA,CAAC;YACO,gBAAgB,gCAAgC,KAAK;YAErD,qBAAqB,SAAS,OAClC,CAAC,MAAM,EAAE,aAAa,iBAAiB,EAAE,aAAa,oBAAoB,GAAG;UAG3E,mBAAmB,WAAW,KAAK,mBAAmB,GAAG,aAAa,eAAe;eAKhF,mBAAmB;AAAA;eAGnB,IAAI,GAAG,IAAI,mBAAmB,QAAQ,KAAK;cAC5C,eAAe,mBAAmB,GAAG,aAAa,KAAK;YACzD,cAAc;iBACT;AAAA;;aAIJ;AAAA,OAGT,CAAC;YACO,OAAO,kBAAkB,gBAAgB,EAAE,IAAI,OAAO,aAAa,EAAE;UACvE,CAAC,MAAM;cACH,QACJ,aAAa,KAAK,UAAU,EAAE,yCAAyC,YACrE,MAAM,GACL;AAAA;aAIA,KAAK,sBAAsB,EAAE;AAAA,OAGtC,CAAC;YACO,OAAO,kBAAkB,gBAAgB,EAAE,IAAI,OAAO,aAAa,EAAE;UACvE,CAAC,MAAM;cACH,QACJ,aAAa,KAAK,UAAU,EAAE,yCAAyC,YACrE,MAAM,GACL;AAAA;aAIA,KAAK,oBAAoB,EAAE;AAAA,KACnC;WAGI;AAAA,KACN,WAAW;AAChB;MAKa,mBAAmB;EAQ9B,YAAY,UAAoC;UACxC,QAAQ;AADgC;AANxC,wCAAe,KAAK,MAAM,KAAK,QAAQ,IAAI,WAAW,CAAC;mBAMf;AAAA;MAJ5C;WACK,KAAK;;;;"}

package/dist/src/types/utility/refinement.mjs

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { getTypeInfo } from "../getTypeInfo.mjs";
+import { resolveTypeChecker, resolveStandardType } from "../resolveTypeChecker.mjs";
+import { lateTypeChecker, TypeChecker, TypeInfo } from "../TypeChecker.mjs";
+import { TypeCheckError } from "../TypeCheckError.mjs";
+function typesRefinement(baseType, checkFn, typeName) {
+  const typeInfoGen = (t) => new RefinementTypeInfo(t, resolveStandardType(baseType), checkFn, typeName);
+  return lateTypeChecker(() => {
+    const baseChecker = resolveTypeChecker(baseType);
+    const getTypeName = (...recursiveTypeCheckers) => {
+      const baseTypeName = baseChecker.getTypeName(...recursiveTypeCheckers, baseChecker);
+      const refinementName = typeName || "refinementOf";
+      return `${refinementName}<${baseTypeName}>`;
+    };
+    const thisTc = new TypeChecker(baseChecker.baseType, (data, path) => {
+      const baseErr = baseChecker.check(data, path);
+      if (baseErr) {
+        return baseErr;
+      }
+      const refinementErr = checkFn(data);
+      if (refinementErr === true) {
+        return null;
+      } else if (refinementErr === false) {
+        return new TypeCheckError(path, getTypeName(thisTc), data);
+      } else {
+        return refinementErr != null ? refinementErr : null;
+      }
+    }, getTypeName, typeInfoGen, (sn) => baseChecker.snapshotType(sn), (sn) => baseChecker.fromSnapshotProcessor(sn), (sn) => baseChecker.toSnapshotProcessor(sn));
+    return thisTc;
+  }, typeInfoGen);
+}
+class RefinementTypeInfo extends TypeInfo {
+  constructor(thisType, baseType, checkFunction, typeName) {
+    super(thisType);
+    __publicField(this, "baseType");
+    __publicField(this, "checkFunction");
+    __publicField(this, "typeName");
+    this.baseType = baseType;
+    this.checkFunction = checkFunction;
+    this.typeName = typeName;
+  }
+  get baseTypeInfo() {
+    return getTypeInfo(this.baseType);
+  }
+}
+export { RefinementTypeInfo, typesRefinement };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVmaW5lbWVudC5tanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90eXBlcy91dGlsaXR5L3JlZmluZW1lbnQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0VHlwZUluZm8gfSBmcm9tIFwiLi4vZ2V0VHlwZUluZm9cIlxyXG5pbXBvcnQgeyByZXNvbHZlU3RhbmRhcmRUeXBlLCByZXNvbHZlVHlwZUNoZWNrZXIgfSBmcm9tIFwiLi4vcmVzb2x2ZVR5cGVDaGVja2VyXCJcclxuaW1wb3J0IHR5cGUgeyBBbnlTdGFuZGFyZFR5cGUsIEFueVR5cGUsIFR5cGVUb0RhdGEgfSBmcm9tIFwiLi4vc2NoZW1hc1wiXHJcbmltcG9ydCB7IGxhdGVUeXBlQ2hlY2tlciwgVHlwZUNoZWNrZXIsIFR5cGVJbmZvLCBUeXBlSW5mb0dlbiB9IGZyb20gXCIuLi9UeXBlQ2hlY2tlclwiXHJcbmltcG9ydCB7IFR5cGVDaGVja0Vycm9yIH0gZnJvbSBcIi4uL1R5cGVDaGVja0Vycm9yXCJcclxuXHJcbi8qKlxyXG4gKiBBIHJlZmluZW1lbnQgb3ZlciBhIGdpdmVuIHR5cGUuIFRoaXMgYWxsb3dzIHlvdSB0byBkbyBleHRyYSBjaGVja3NcclxuICogb3ZlciBtb2RlbHMsIGVuc3VyZSBudW1iZXJzIGFyZSBpbnRlZ2VycywgZXRjLlxyXG4gKlxyXG4gKiBFeGFtcGxlOlxyXG4gKiBgYGB0c1xyXG4gKiBjb25zdCBpbnRlZ2VyVHlwZSA9IHR5cGVzLnJlZmluZW1lbnQodHlwZXMubnVtYmVyLCAobikgPT4ge1xyXG4gKiAgIHJldHVybiBOdW1iZXIuaXNJbnRlZ2VyKG4pXHJcbiAqIH0sIFwiaW50ZWdlclwiKVxyXG4gKlxyXG4gKiBjb25zdCBzdW1Nb2RlbFR5cGUgPSB0eXBlcy5yZWZpbmVtZW50KHR5cGVzLm1vZGVsKFN1bSksIChzdW0pID0+IHtcclxuICogICAvLyBpbWFnaW5lIHRoYXQgZm9yIHNvbWUgcmVhc29uIHN1bSBpbmNsdWRlcyBhIG51bWJlciAnYScsIGEgbnVtYmVyICdiJ1xyXG4gKiAgIC8vIGFuZCB0aGUgcmVzdWx0XHJcbiAqXHJcbiAqICAgY29uc3QgcmlnaHRSZXN1bHQgPSBzdW0uYSArIHN1bS5iID09PSBzdW0ucmVzdWx0XHJcbiAqXHJcbiAqICAgLy8gc2ltcGxlIG1vZGUgdGhhdCB3aWxsIGp1c3QgcmV0dXJuIHRoYXQgdGhlIHdob2xlIG1vZGVsIGlzIGluY29ycmVjdFxyXG4gKiAgIHJldHVybiByaWdodFJlc3VsdFxyXG4gKlxyXG4gKiAgIC8vIHRoaXMgd2lsbCByZXR1cm4gdGhhdCB0aGUgcmVzdWx0IGZpZWxkIGlzIHdyb25nXHJcbiAqICAgcmV0dXJuIHJpZ2h0UmVzdWx0ID8gbnVsbCA6IG5ldyBUeXBlQ2hlY2tFcnJvcihbXCJyZXN1bHRcIl0sIFwiYStiXCIsIHN1bS5yZXN1bHQpXHJcbiAqIH0pXHJcbiAqIGBgYFxyXG4gKlxyXG4gKiBAdHlwZXBhcmFtIFQgQmFzZSB0eXBlLlxyXG4gKiBAcGFyYW0gYmFzZVR5cGUgQmFzZSB0eXBlLlxyXG4gKiBAcGFyYW0gY2hlY2tGbiBGdW5jdGlvbiB0aGF0IHdpbGwgcmVjZWl2ZSB0aGUgZGF0YSAoaWYgaXQgcGFzc2VzIHRoZSBiYXNlIHR5cGVcclxuICogY2hlY2spIGFuZCByZXR1cm4gbnVsbCBvciBmYWxzZSBpZiB0aGVyZSB3ZXJlIG5vIGVycm9ycyBvciBlaXRoZXIgYSBUeXBlQ2hlY2tFcnJvciBpbnN0YW5jZSBvclxyXG4gKiB0cnVlIGlmIHRoZXJlIHdlcmUuXHJcbiAqIEByZXR1cm5zXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gdHlwZXNSZWZpbmVtZW50PFQgZXh0ZW5kcyBBbnlUeXBlPihcclxuICBiYXNlVHlwZTogVCxcclxuICBjaGVja0ZuOiAoZGF0YTogVHlwZVRvRGF0YTxUPikgPT4gVHlwZUNoZWNrRXJyb3IgfCBudWxsIHwgYm9vbGVhbixcclxuICB0eXBlTmFtZT86IHN0cmluZ1xyXG4pOiBUIHtcclxuICBjb25zdCB0eXBlSW5mb0dlbjogVHlwZUluZm9HZW4gPSAodCkgPT5cclxuICAgIG5ldyBSZWZpbmVtZW50VHlwZUluZm8odCwgcmVzb2x2ZVN0YW5kYXJkVHlwZShiYXNlVHlwZSksIGNoZWNrRm4sIHR5cGVOYW1lKVxyXG5cclxuICByZXR1cm4gbGF0ZVR5cGVDaGVja2VyKCgpID0+IHtcclxuICAgIGNvbnN0IGJhc2VDaGVja2VyID0gcmVzb2x2ZVR5cGVDaGVja2VyKGJhc2VUeXBlKVxyXG5cclxuICAgIGNvbnN0IGdldFR5cGVOYW1lID0gKC4uLnJlY3Vyc2l2ZVR5cGVDaGVja2VyczogVHlwZUNoZWNrZXJbXSkgPT4ge1xyXG4gICAgICBjb25zdCBiYXNlVHlwZU5hbWUgPSBiYXNlQ2hlY2tlci5nZXRUeXBlTmFtZSguLi5yZWN1cnNpdmVUeXBlQ2hlY2tlcnMsIGJhc2VDaGVja2VyKVxyXG4gICAgICBjb25zdCByZWZpbmVtZW50TmFtZSA9IHR5cGVOYW1lIHx8IFwicmVmaW5lbWVudE9mXCJcclxuICAgICAgcmV0dXJuIGAke3JlZmluZW1lbnROYW1lfTwke2Jhc2VUeXBlTmFtZX0+YFxyXG4gICAgfVxyXG5cclxuICAgIGNvbnN0IHRoaXNUYzogVHlwZUNoZWNrZXIgPSBuZXcgVHlwZUNoZWNrZXIoXHJcbiAgICAgIGJhc2VDaGVja2VyLmJhc2VUeXBlLFxyXG5cclxuICAgICAgKGRhdGEsIHBhdGgpID0+IHtcclxuICAgICAgICBjb25zdCBiYXNlRXJyID0gYmFzZUNoZWNrZXIuY2hlY2soZGF0YSwgcGF0aClcclxuICAgICAgICBpZiAoYmFzZUVycikge1xyXG4gICAgICAgICAgcmV0dXJuIGJhc2VFcnJcclxuICAgICAgICB9XHJcblxyXG4gICAgICAgIGNvbnN0IHJlZmluZW1lbnRFcnIgPSBjaGVja0ZuKGRhdGEpXHJcblxyXG4gICAgICAgIGlmIChyZWZpbmVtZW50RXJyID09PSB0cnVlKSB7XHJcbiAgICAgICAgICByZXR1cm4gbnVsbFxyXG4gICAgICAgIH0gZWxzZSBpZiAocmVmaW5lbWVudEVyciA9PT0gZmFsc2UpIHtcclxuICAgICAgICAgIHJldHVybiBuZXcgVHlwZUNoZWNrRXJyb3IocGF0aCwgZ2V0VHlwZU5hbWUodGhpc1RjKSwgZGF0YSlcclxuICAgICAgICB9IGVsc2Uge1xyXG4gICAgICAgICAgcmV0dXJuIHJlZmluZW1lbnRFcnIgPz8gbnVsbFxyXG4gICAgICAgIH1cclxuICAgICAgfSxcclxuXHJcbiAgICAgIGdldFR5cGVOYW1lLFxyXG4gICAgICB0eXBlSW5mb0dlbixcclxuXHJcbiAgICAgIC8vIHdlIGNhbm5vdCBjaGVjayByZWZpbmVtZW50IGhlcmUgc2luY2UgaXQgY2hlY2tzIGRhdGEgaW5zdGFuY2VzLCBub3Qgc25hcHNob3RzXHJcbiAgICAgIChzbikgPT4gYmFzZUNoZWNrZXIuc25hcHNob3RUeXBlKHNuKSxcclxuXHJcbiAgICAgIChzbikgPT4gYmFzZUNoZWNrZXIuZnJvbVNuYXBzaG90UHJvY2Vzc29yKHNuKSxcclxuICAgICAgKHNuKSA9PiBiYXNlQ2hlY2tlci50b1NuYXBzaG90UHJvY2Vzc29yKHNuKVxyXG4gICAgKVxyXG5cclxuICAgIHJldHVybiB0aGlzVGNcclxuICB9LCB0eXBlSW5mb0dlbikgYXMgYW55XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBgdHlwZXMucmVmaW5lbWVudGAgdHlwZSBpbmZvLlxyXG4gKi9cclxuZXhwb3J0IGNsYXNzIFJlZmluZW1lbnRUeXBlSW5mbyBleHRlbmRzIFR5cGVJbmZvIHtcclxuICBnZXQgYmFzZVR5cGVJbmZvKCk6IFR5cGVJbmZvIHtcclxuICAgIHJldHVybiBnZXRUeXBlSW5mbyh0aGlzLmJhc2VUeXBlKVxyXG4gIH1cclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICB0aGlzVHlwZTogQW55U3RhbmRhcmRUeXBlLFxyXG4gICAgcmVhZG9ubHkgYmFzZVR5cGU6IEFueVN0YW5kYXJkVHlwZSxcclxuICAgIHJlYWRvbmx5IGNoZWNrRnVuY3Rpb246IChkYXRhOiBhbnkpID0+IFR5cGVDaGVja0Vycm9yIHwgbnVsbCB8IGJvb2xlYW4sXHJcbiAgICByZWFkb25seSB0eXBlTmFtZTogc3RyaW5nIHwgdW5kZWZpbmVkXHJcbiAgKSB7XHJcbiAgICBzdXBlcih0aGlzVHlwZSlcclxuICB9XHJcbn1cclxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7eUJBc0NFLFVBQ0EsU0FDQTtRQUVNLGNBQTJCLENBQUMsTUFDaEMsSUFBSSxtQkFBbUIsR0FBRyxvQkFBb0IsUUFBUSxHQUFHLFNBQVMsUUFBUTtTQUVyRSxnQkFBZ0I7VUFDZixjQUFjLG1CQUFtQixRQUFRO1VBRXpDLGNBQWMsSUFBSTtZQUNoQixlQUFlLFlBQVksWUFBWSxHQUFHLHVCQUF1QixXQUFXO1lBQzVFLGlCQUFpQixZQUFZO2FBQzVCLEdBQUcsa0JBQWtCO0FBQUE7VUFHeEIsU0FBc0IsSUFBSSxZQUM5QixZQUFZLFVBRVosQ0FBQyxNQUFNO1lBQ0MsVUFBVSxZQUFZLE1BQU0sTUFBTSxJQUFJO1VBQ3hDLFNBQVM7ZUFDSjtBQUFBO1lBR0gsZ0JBQWdCLFFBQVEsSUFBSTtVQUU5QixrQkFBa0IsTUFBTTtlQUNuQjtBQUFBLGlCQUNFLGtCQUFrQixPQUFPO2VBQzNCLElBQUksZUFBZSxNQUFNLFlBQVksTUFBTSxHQUFHLElBQUk7QUFBQSxhQUNwRDtlQUNFLHdDQUFpQjtBQUFBO09BSTVCLGFBQ0EsYUFHQSxDQUFDLE9BQU8sWUFBWSxhQUFhLEVBQUUsR0FFbkMsQ0FBQyxPQUFPLFlBQVksc0JBQXNCLEVBQUUsR0FDNUMsQ0FBQyxPQUFPLFlBQVksb0JBQW9CLEVBQUUsQ0FBQztXQUd0QztBQUFBLEtBQ04sV0FBVztBQUNoQjtNQUthLDJCQUEyQjtFQUt0QyxZQUNFLFVBQ1MsVUFDQSxlQUNBO1VBRUgsUUFBUTtBQUpMO0FBQ0E7QUFDQTtvQkFGQTt5QkFDQTtvQkFDQTtBQUFBO01BUlA7V0FDSyxZQUFZLEtBQUssUUFBUTtBQUFBOzs7In0=

package/dist/src/types/utility/unchecked.mjs

@@ -0,0 +1,10 @@
+import { identityFn } from "../../utils/index.mjs";
+import { TypeChecker, TypeCheckerBaseType, TypeInfo } from "../TypeChecker.mjs";
+const unchecked = new TypeChecker(TypeCheckerBaseType.Any, null, () => "any", (t) => new UncheckedTypeInfo(t), () => unchecked, identityFn, identityFn);
+function typesUnchecked() {
+  return unchecked;
+}
+class UncheckedTypeInfo extends TypeInfo {
+}
+export { UncheckedTypeInfo, typesUnchecked };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5jaGVja2VkLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3R5cGVzL3V0aWxpdHkvdW5jaGVja2VkLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGlkZW50aXR5Rm4gfSBmcm9tIFwiLi4vLi4vdXRpbHNcIlxyXG5pbXBvcnQgdHlwZSB7IElkZW50aXR5VHlwZSB9IGZyb20gXCIuLi9zY2hlbWFzXCJcclxuaW1wb3J0IHsgVHlwZUNoZWNrZXIsIFR5cGVDaGVja2VyQmFzZVR5cGUsIFR5cGVJbmZvIH0gZnJvbSBcIi4uL1R5cGVDaGVja2VyXCJcclxuXHJcbmNvbnN0IHVuY2hlY2tlZDogSWRlbnRpdHlUeXBlPGFueT4gPSBuZXcgVHlwZUNoZWNrZXIoXHJcbiAgVHlwZUNoZWNrZXJCYXNlVHlwZS5BbnksXHJcbiAgbnVsbCxcclxuICAoKSA9PiBcImFueVwiLFxyXG4gICh0KSA9PiBuZXcgVW5jaGVja2VkVHlwZUluZm8odCksXHJcblxyXG4gICgpID0+IHVuY2hlY2tlZCBhcyBhbnksXHJcblxyXG4gIGlkZW50aXR5Rm4sXHJcbiAgaWRlbnRpdHlGblxyXG4pIGFzIGFueVxyXG5cclxuLyoqXHJcbiAqIEEgdHlwZSB0aGF0IHJlcHJlc2VudHMgYSBnaXZlbiB2YWx1ZSB0aGF0IHdvbid0IGJlIHR5cGUgY2hlY2tlZC5cclxuICogVGhpcyBpcyBiYXNpY2FsbHkgYSB3YXkgdG8gYmFpbCBvdXQgb2YgdGhlIHJ1bnRpbWUgdHlwZSBjaGVja2luZyBzeXN0ZW0uXHJcbiAqXHJcbiAqIEV4YW1wbGU6XHJcbiAqIGBgYHRzXHJcbiAqIGNvbnN0IHVuY2hlY2tlZFNvbWVNb2RlbCA9IHR5cGVzLnVuY2hlY2tlZDxTb21lTW9kZWw+KClcclxuICogY29uc3QgYW55VHlwZSA9IHR5cGVzLnVuY2hlY2tlZDxhbnk+KClcclxuICogY29uc3QgY3VzdG9tVW5jaGVja2VkVHlwZSA9IHR5cGVzLnVuY2hlY2tlZDwoQSAmIEIpIHwgQz4oKVxyXG4gKiBgYGBcclxuICpcclxuICogQHR5cGVwYXJhbSBUIFR5cGUgb2YgdGhlIHZhbHVlLCBvciB1bmtvd24gaWYgbm90IGdpdmVuLlxyXG4gKiBAcmV0dXJuc1xyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIHR5cGVzVW5jaGVja2VkPFQgPSBuZXZlcj4oKTogSWRlbnRpdHlUeXBlPFQ+IHtcclxuICByZXR1cm4gdW5jaGVja2VkXHJcbn1cclxuXHJcbi8qKlxyXG4gKiBgdHlwZXMudW5jaGVja2VkYCB0eXBlIGluZm8uXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgVW5jaGVja2VkVHlwZUluZm8gZXh0ZW5kcyBUeXBlSW5mbyB7fVxyXG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSxNQUFNLFlBQStCLElBQUksWUFDdkMsb0JBQW9CLEtBQ3BCLE1BQ0EsTUFBTSxPQUNOLENBQUMsTUFBTSxJQUFJLGtCQUFrQixDQUFDLEdBRTlCLE1BQU0sV0FFTixZQUNBLFVBQVU7O1NBa0JIO0FBQ1Q7TUFLYSwwQkFBMEI7OzsifQ==

package/dist/src/utils/ModelPool.mjs

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { getModelIdPropertyName } from "../model/getModelMetadata.mjs";
+import { modelIdKey, modelTypeKey } from "../model/metadata.mjs";
+import { isModel, isModelSnapshot } from "../model/utils.mjs";
+import { getModelInfoForName } from "../modelShared/modelInfo.mjs";
+import { dataObjectParent } from "../parent/core.mjs";
+import { registerDeepObjectChildrenExtension, getDeepObjectChildren } from "../parent/coreObjectChildren.mjs";
+function byModelTypeAndIdKey(modelType, modelId) {
+  return modelType + " " + modelId;
+}
+class ModelPool {
+  constructor(root) {
+    __publicField(this, "pool");
+    var _a;
+    root = (_a = dataObjectParent.get(root)) != null ? _a : root;
+    this.pool = getDeepChildrenModels(getDeepObjectChildren(root));
+  }
+  findModelByTypeAndId(modelType, modelId) {
+    return modelId ? this.pool.get(byModelTypeAndIdKey(modelType, modelId)) : void 0;
+  }
+  findModelForSnapshot(sn) {
+    if (!isModelSnapshot(sn)) {
+      return void 0;
+    }
+    const modelType = sn[modelTypeKey];
+    const modelInfo = getModelInfoForName(modelType);
+    const modelIdPropertyName = getModelIdPropertyName(modelInfo.class);
+    return modelIdPropertyName ? this.findModelByTypeAndId(sn[modelTypeKey], sn[modelIdPropertyName]) : void 0;
+  }
+}
+const getDeepChildrenModels = registerDeepObjectChildrenExtension({
+  initData() {
+    return /* @__PURE__ */ new Map();
+  },
+  addNode(node, data) {
+    if (isModel(node)) {
+      const id = node[modelIdKey];
+      if (id) {
+        data.set(byModelTypeAndIdKey(node[modelTypeKey], id), node);
+      }
+    }
+  }
+});
+export { ModelPool };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/utils/chainFns.mjs

@@ -0,0 +1,15 @@
+function chainFns(...fns) {
+  const definedFns = fns.filter((fn) => !!fn);
+  if (definedFns.length <= 0)
+    return void 0;
+  const chainedFn = (v, ...args) => {
+    let ret = v;
+    for (let i = 0; i < definedFns.length; i++) {
+      ret = definedFns[i](ret, ...args);
+    }
+    return ret;
+  };
+  return chainedFn;
+}
+export { chainFns };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5GbnMubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvY2hhaW5GbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGNoYWluRm5zPEYgZXh0ZW5kcyBGdW5jdGlvbj4oLi4uZm5zOiAoRiB8IHVuZGVmaW5lZClbXSk6IEYgfCB1bmRlZmluZWQge1xuICBjb25zdCBkZWZpbmVkRm5zID0gZm5zLmZpbHRlcigoZm4pID0+ICEhZm4pXG4gIGlmIChkZWZpbmVkRm5zLmxlbmd0aCA8PSAwKSByZXR1cm4gdW5kZWZpbmVkXG5cbiAgY29uc3QgY2hhaW5lZEZuID0gKHY6IGFueSwgLi4uYXJnczogYW55W10pID0+IHtcbiAgICBsZXQgcmV0ID0gdlxuXG4gICAgZm9yIChsZXQgaSA9IDA7IGkgPCBkZWZpbmVkRm5zLmxlbmd0aDsgaSsrKSB7XG4gICAgICByZXQgPSBkZWZpbmVkRm5zW2ldIShyZXQsIC4uLmFyZ3MpXG4gICAgfVxuXG4gICAgcmV0dXJuIHJldFxuICB9XG5cbiAgcmV0dXJuIGNoYWluZWRGbiBhcyB1bmtub3duIGFzIEZcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoicUJBQWdEO1FBQ3hDLGFBQWEsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsRUFBRTtNQUN0QyxXQUFXLFVBQVU7V0FBVTtRQUU3QixZQUFZLENBQUMsTUFBVztRQUN4QixNQUFNO2FBRUQsSUFBSSxHQUFHLElBQUksV0FBVyxRQUFRLEtBQUs7WUFDcEMsV0FBVyxHQUFJLEtBQUssR0FBRyxJQUFJO0FBQUE7V0FHNUI7QUFBQTtTQUdGO0FBQ1Q7OyJ9

package/dist/src/utils/index.mjs

@@ -0,0 +1,228 @@
+import * as mobx from "mobx";
+import { isObservableMap, isObservableSet, isObservableArray, isObservableObject } from "mobx";
+class MobxKeystoneError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, MobxKeystoneError.prototype);
+  }
+}
+function failure(msg) {
+  return new MobxKeystoneError(msg);
+}
+const writableHiddenPropDescriptor = {
+  enumerable: false,
+  writable: true,
+  configurable: false,
+  value: void 0
+};
+function addHiddenProp(object, propName, value, writable = true) {
+  if (writable) {
+    Object.defineProperty(object, propName, writableHiddenPropDescriptor);
+    object[propName] = value;
+  } else {
+    Object.defineProperty(object, propName, {
+      enumerable: false,
+      writable,
+      configurable: true,
+      value
+    });
+  }
+}
+function makePropReadonly(object, propName, enumerable) {
+  const propDesc = Object.getOwnPropertyDescriptor(object, propName);
+  if (propDesc) {
+    propDesc.enumerable = enumerable;
+    if (propDesc.get) {
+      delete propDesc.set;
+    } else {
+      propDesc.writable = false;
+    }
+    Object.defineProperty(object, propName, propDesc);
+  }
+}
+function isPlainObject(value) {
+  if (!isObject(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isPrimitive(value) {
+  switch (typeof value) {
+    case "number":
+    case "string":
+    case "boolean":
+    case "undefined":
+    case "bigint":
+      return true;
+  }
+  return value === null;
+}
+function isJSONPrimitive(value) {
+  switch (typeof value) {
+    case "number":
+      return isFinite(value);
+    case "string":
+    case "boolean":
+      return true;
+  }
+  return value === null;
+}
+function deleteFromArray(array, value) {
+  let index = array.indexOf(value);
+  if (index >= 0) {
+    array.splice(index, 1);
+    return true;
+  }
+  return false;
+}
+function isMap(val) {
+  return val instanceof Map || isObservableMap(val);
+}
+function isSet(val) {
+  return val instanceof Set || isObservableSet(val);
+}
+function isArray(val) {
+  return Array.isArray(val) || isObservableArray(val);
+}
+function inDevMode() {
+  return false;
+}
+function assertIsObject(value, argName) {
+  if (!isObject(value)) {
+    throw failure(`${argName} must be an object`);
+  }
+}
+function assertIsPlainObject(value, argName) {
+  if (!isPlainObject(value)) {
+    throw failure(`${argName} must be a plain object`);
+  }
+}
+function assertIsObservableObject(value, argName) {
+  if (!isObservableObject(value)) {
+    throw failure(`${argName} must be an observable object`);
+  }
+}
+function assertIsObservableArray(value, argName) {
+  if (!isObservableArray(value)) {
+    throw failure(`${argName} must be an observable array`);
+  }
+}
+function assertIsMap(value, argName) {
+  if (!isMap(value)) {
+    throw failure(`${argName} must be a map`);
+  }
+}
+function assertIsSet(value, argName) {
+  if (!isSet(value)) {
+    throw failure(`${argName} must be a set`);
+  }
+}
+function assertIsFunction(value, argName) {
+  if (typeof value !== "function") {
+    throw failure(`${argName} must be a function`);
+  }
+}
+function assertIsPrimitive(value, argName) {
+  if (!isPrimitive(value)) {
+    throw failure(`${argName} must be a primitive`);
+  }
+}
+function assertIsString(value, argName) {
+  if (typeof value !== "string") {
+    throw failure(`${argName} must be a string`);
+  }
+}
+const runAfterNewSymbol = Symbol("runAfterNew");
+const runBeforeOnInitSymbol = Symbol("runBeforeOnInit");
+function addLateInitializationFunction(target, symbol, fn) {
+  let array = target[symbol];
+  if (!array) {
+    array = [];
+    addHiddenProp(target, symbol, array);
+  }
+  array.push(fn);
+}
+function decorateWrapMethodOrField(decoratorName, data, wrap) {
+  const { target, propertyKey, baseDescriptor } = data;
+  const addFieldDecorator = () => {
+    addLateInitializationFunction(target, runAfterNewSymbol, (instance) => {
+      instance[propertyKey] = wrap(data, instance[propertyKey]);
+    });
+  };
+  if (baseDescriptor) {
+    if (baseDescriptor.get !== void 0) {
+      throw failure(`@${decoratorName} cannot be used with getters`);
+    }
+    if (baseDescriptor.value) {
+      return {
+        enumerable: false,
+        writable: true,
+        configurable: true,
+        value: wrap(data, baseDescriptor.value)
+      };
+    } else {
+      addFieldDecorator();
+    }
+  } else {
+    addFieldDecorator();
+  }
+}
+function runLateInitializationFunctions(target, symbol) {
+  const fns = target[symbol];
+  if (fns) {
+    for (const fn of fns) {
+      fn(target);
+    }
+  }
+}
+const warningsAlreadyDisplayed = /* @__PURE__ */ new Set();
+function logWarning(type, msg, uniqueKey) {
+  if (uniqueKey) {
+    if (warningsAlreadyDisplayed.has(uniqueKey)) {
+      return;
+    }
+    warningsAlreadyDisplayed.add(uniqueKey);
+  }
+  msg = "[mobx-keystone] " + msg;
+  switch (type) {
+    case "warn":
+      console.warn(msg);
+      break;
+    case "error":
+      console.error(msg);
+      break;
+    default:
+      throw failure(`unknown log type - ${type}`);
+  }
+}
+function lazy(getter) {
+  let memoizedValue;
+  let memoized = false;
+  return (...args) => {
+    if (!memoized) {
+      memoizedValue = getter(...args);
+      memoized = true;
+    }
+    return memoizedValue;
+  };
+}
+const identityFn = (x) => x;
+const mobx6 = {
+  makeObservable: mobx[String.fromCharCode("l".charCodeAt(0) + 1) + "akeObservable"]
+};
+function propNameToSetterName(propName) {
+  return `set${propName[0].toUpperCase()}${propName.slice(1)}`;
+}
+function getMobxVersion() {
+  if (mobx6.makeObservable) {
+    return 6;
+  } else {
+    return 5;
+  }
+}
+const namespace = "mobx-keystone";
+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 };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.mjs","sources":["../../../src/utils/index.ts"],"sourcesContent":["import * as mobx from \"mobx\"\nimport {\n  IObservableArray,\n  isObservableArray,\n  isObservableMap,\n  isObservableObject,\n  isObservableSet,\n  ObservableMap,\n  ObservableSet,\n} from \"mobx\"\nimport { JSONPrimitiveValue, PrimitiveValue } from \"./types\"\n\n/**\n * A mobx-keystone error.\n */\nexport class MobxKeystoneError extends Error {\n  constructor(msg: string) {\n    super(msg)\n\n    // Set the prototype explicitly.\n    Object.setPrototypeOf(this, MobxKeystoneError.prototype)\n  }\n}\n\n/**\n * @internal\n */\nexport function failure(msg: string) {\n  return new MobxKeystoneError(msg)\n}\n\nconst writableHiddenPropDescriptor: PropertyDescriptor = {\n  enumerable: false,\n  writable: true,\n  configurable: false,\n  value: undefined,\n}\n\n/**\n * @internal\n */\nexport function addHiddenProp(object: any, propName: PropertyKey, value: any, writable = true) {\n  if (writable) {\n    Object.defineProperty(object, propName, writableHiddenPropDescriptor)\n    object[propName] = value\n  } else {\n    Object.defineProperty(object, propName, {\n      enumerable: false,\n      writable,\n      configurable: true,\n      value,\n    })\n  }\n}\n\n/**\n * @internal\n */\nexport function makePropReadonly<T>(object: T, propName: keyof T, enumerable: boolean) {\n  const propDesc = Object.getOwnPropertyDescriptor(object, propName)\n  if (propDesc) {\n    propDesc.enumerable = enumerable\n    if (propDesc.get) {\n      delete propDesc.set\n    } else {\n      propDesc.writable = false\n    }\n    Object.defineProperty(object, propName, propDesc)\n  }\n}\n\n/**\n * @internal\n */\nexport function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (!isObject(value)) return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\n/**\n * @internal\n */\nexport function isObject(value: unknown): value is Record<PropertyKey, unknown> {\n  return value !== null && typeof value === \"object\"\n}\n\n/**\n * @internal\n */\nexport function isPrimitive(value: unknown): value is PrimitiveValue {\n  switch (typeof value) {\n    case \"number\":\n    case \"string\":\n    case \"boolean\":\n    case \"undefined\":\n    case \"bigint\":\n      return true\n  }\n  return value === null\n}\n\n/**\n * @internal\n */\nexport function isJSONPrimitive(value: unknown): value is JSONPrimitiveValue {\n  switch (typeof value) {\n    case \"number\":\n      return isFinite(value)\n    case \"string\":\n    case \"boolean\":\n      return true\n  }\n  return value === null\n}\n\n/**\n * @internal\n */\nexport function deleteFromArray<T>(array: T[], value: T): boolean {\n  let index = array.indexOf(value)\n  if (index >= 0) {\n    array.splice(index, 1)\n    return true\n  }\n  return false\n}\n\n/**\n * @internal\n */\nexport function isMap(val: unknown): val is Map<any, any> | ObservableMap {\n  return val instanceof Map || isObservableMap(val)\n}\n\n/**\n * @internal\n */\nexport function isSet(val: unknown): val is Set<any> | ObservableSet {\n  return val instanceof Set || isObservableSet(val)\n}\n\n/**\n * @internal\n */\nexport function isArray(val: unknown): val is any[] | IObservableArray {\n  return Array.isArray(val) || isObservableArray(val)\n}\n\n/**\n * @internal\n */\nexport function inDevMode(): boolean {\n  return process.env.NODE_ENV !== \"production\"\n}\n\n/**\n * @internal\n */\nexport function assertIsObject(value: unknown, argName: string): asserts value is object {\n  if (!isObject(value)) {\n    throw failure(`${argName} must be an object`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsPlainObject(value: unknown, argName: string): asserts value is object {\n  if (!isPlainObject(value)) {\n    throw failure(`${argName} must be a plain object`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsObservableObject(value: unknown, argName: string): asserts value is object {\n  if (!isObservableObject(value)) {\n    throw failure(`${argName} must be an observable object`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsObservableArray(\n  value: unknown,\n  argName: string\n): asserts value is IObservableArray {\n  if (!isObservableArray(value)) {\n    throw failure(`${argName} must be an observable array`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsMap(value: unknown, argName: string): asserts value is Map<any, any> {\n  if (!isMap(value)) {\n    throw failure(`${argName} must be a map`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsSet(value: unknown, argName: string): asserts value is Set<any> {\n  if (!isSet(value)) {\n    throw failure(`${argName} must be a set`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsFunction(value: unknown, argName: string): asserts value is Function {\n  if (typeof value !== \"function\") {\n    throw failure(`${argName} must be a function`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsPrimitive(\n  value: unknown,\n  argName: string\n): asserts value is PrimitiveValue {\n  if (!isPrimitive(value)) {\n    throw failure(`${argName} must be a primitive`)\n  }\n}\n\n/**\n * @internal\n */\nexport function assertIsString(value: unknown, argName: string): asserts value is string {\n  if (typeof value !== \"string\") {\n    throw failure(`${argName} must be a string`)\n  }\n}\n\n/**\n * @internal\n */\nexport interface DecorateMethodOrFieldData {\n  target: any\n  propertyKey: string\n  baseDescriptor?: PropertyDescriptor & { initializer?: () => any }\n}\n\n/**\n * @internal\n */\nexport const runAfterNewSymbol = Symbol(\"runAfterNew\")\n\n/**\n * @internal\n */\nexport const runBeforeOnInitSymbol = Symbol(\"runBeforeOnInit\")\n\ntype WrapFunction = (data: DecorateMethodOrFieldData, fn: any) => any\ntype LateInitializationFunctionsArray = ((instance: any) => void)[]\n\n/**\n * @internal\n */\nexport function addLateInitializationFunction(\n  target: any,\n  symbol: symbol,\n  fn: (instance: any) => void\n) {\n  let array: LateInitializationFunctionsArray = target[symbol]\n  if (!array) {\n    array = []\n    addHiddenProp(target, symbol, array)\n  }\n  array.push(fn)\n}\n\n/**\n * @internal\n */\nexport function decorateWrapMethodOrField(\n  decoratorName: string,\n  data: DecorateMethodOrFieldData,\n  wrap: WrapFunction\n): any {\n  const { target, propertyKey, baseDescriptor } = data\n\n  const addFieldDecorator = () => {\n    addLateInitializationFunction(target, runAfterNewSymbol, (instance) => {\n      instance[propertyKey] = wrap(data, instance[propertyKey])\n    })\n  }\n\n  if (baseDescriptor) {\n    if (baseDescriptor.get !== undefined) {\n      throw failure(`@${decoratorName} cannot be used with getters`)\n    }\n\n    if (baseDescriptor.value) {\n      // babel / typescript - method decorator\n      // @action method() { }\n      return {\n        enumerable: false,\n        writable: true,\n        configurable: true,\n        value: wrap(data, baseDescriptor.value),\n      }\n    } else {\n      // babel - field decorator: @action method = () => {}\n      addFieldDecorator()\n    }\n  } else {\n    // typescript - field decorator\n    addFieldDecorator()\n  }\n}\n\n/**\n * @internal\n */\nexport function runLateInitializationFunctions(target: any, symbol: symbol): void {\n  const fns: LateInitializationFunctionsArray | undefined = target[symbol]\n  if (fns) {\n    for (const fn of fns) {\n      fn(target)\n    }\n  }\n}\n\nconst warningsAlreadyDisplayed = new Set<string>()\n\n/**\n * @internal\n */\nexport function logWarning(type: \"warn\" | \"error\", msg: string, uniqueKey?: string): void {\n  if (uniqueKey) {\n    if (warningsAlreadyDisplayed.has(uniqueKey)) {\n      return\n    }\n    warningsAlreadyDisplayed.add(uniqueKey)\n  }\n\n  msg = \"[mobx-keystone] \" + msg\n  switch (type) {\n    case \"warn\":\n      console.warn(msg)\n      break\n    case \"error\":\n      console.error(msg)\n      break\n    default:\n      throw failure(`unknown log type - ${type}`)\n  }\n}\n\n/**\n * @internal\n */\nexport function lazy<A extends unknown[], R>(getter: (...args: A) => R): typeof getter {\n  let memoizedValue: R\n  let memoized = false\n\n  return (...args: A): R => {\n    if (!memoized) {\n      memoizedValue = getter(...args)\n      memoized = true\n    }\n    return memoizedValue\n  }\n}\n\n/**\n * @internal\n */\nexport const identityFn = <T>(x: T): T => x\n\n/**\n * @internal\n */\nexport const mobx6 = {\n  // eslint-disable-next-line no-useless-concat\n  makeObservable: (mobx as any)[\n    // just to ensure import * is kept properly\n    String.fromCharCode(\"l\".charCodeAt(0) + 1) + \"akeObservable\"\n  ],\n}\n\n/**\n * @internal\n */\nexport function propNameToSetterName(propName: string): string {\n  return `set${propName[0].toUpperCase()}${propName.slice(1)}`\n}\n\n/**\n * @internal\n */\nexport function getMobxVersion(): number {\n  if (mobx6.makeObservable!) {\n    return 6\n  } else {\n    return 5\n  }\n}\n\n/**\n * @internal\n */\nexport const namespace = \"mobx-keystone\"\n"],"names":[],"mappings":"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"}

package/dist/src/utils/mapUtils.mjs

@@ -0,0 +1,10 @@
+function getOrCreate(map, key, create) {
+  let value = map.get(key);
+  if (value === void 0) {
+    value = create();
+    map.set(key, value);
+  }
+  return value;
+}
+export { getOrCreate };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwVXRpbHMubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvbWFwVXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsidHlwZSBBbnlNYXA8ViA9IGFueT4gPSBNYXA8YW55LCBWPiB8IFdlYWtNYXA8YW55LCBWPlxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0T3JDcmVhdGU8SywgViwgQyA9IFY+KG1hcDogTWFwPEssIFY+LCBrZXk6IEssIGNyZWF0ZTogKCkgPT4gQyk6IFZcbmV4cG9ydCBmdW5jdGlvbiBnZXRPckNyZWF0ZTxLIGV4dGVuZHMgb2JqZWN0LCBWLCBDID0gVj4oXG4gIG1hcDogV2Vha01hcDxLLCBWPixcbiAga2V5OiBLLFxuICBjcmVhdGU6ICgpID0+IENcbik6IFZcblxuZXhwb3J0IGZ1bmN0aW9uIGdldE9yQ3JlYXRlPFY+KG1hcDogQW55TWFwPFY+LCBrZXk6IGFueSwgY3JlYXRlOiAoKSA9PiBWKSB7XG4gIGxldCB2YWx1ZSA9IG1hcC5nZXQoa2V5KVxuICBpZiAodmFsdWUgPT09IHVuZGVmaW5lZCkge1xuICAgIHZhbHVlID0gY3JlYXRlKClcbiAgICBtYXAuc2V0KGtleSwgdmFsdWUpXG4gIH1cbiAgcmV0dXJuIHZhbHVlXG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6InFCQVMrQixLQUFnQixLQUFVO01BQ25ELFFBQVEsSUFBSSxJQUFJLEdBQUc7TUFDbkIsVUFBVSxRQUFXO1lBQ2Y7UUFDSixJQUFJLEtBQUssS0FBSztBQUFBO1NBRWI7QUFDVDs7In0=

package/dist/src/utils/tag.mjs

@@ -0,0 +1,16 @@
+function tag(tagDataConstructor) {
+  const map = /* @__PURE__ */ new WeakMap();
+  return {
+    for(target) {
+      if (!map.has(target)) {
+        const data = tagDataConstructor(target);
+        map.set(target, data);
+        return data;
+      } else {
+        return map.get(target);
+      }
+    }
+  };
+}
+export { tag };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL3RhZy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENyZWF0ZXMgYSB0YWcgZGF0YSBhY2Nlc3NvciBmb3IgYSB0YXJnZXQgb2JqZWN0IG9mIGEgY2VydGFpbiB0eXBlLlxuICogVGFnIGRhdGEgd2lsbCBiZSBsYXp5IGNyZWF0ZWQgb24gYWNjZXNzIGFuZCByZXVzZWQgZm9yIHRoZSBzYW1lIHRhcmdldCBvYmplY3QuXG4gKlxuICogQHR5cGVwYXJhbSBUYXJnZXQgVGFyZ2V0IHR5cGUuXG4gKiBAdHlwZXBhcmFtIFRhZ0RhdGEgVGFnIGRhdGEgdHlwZS5cbiAqIEBwYXJhbSB0YWdEYXRhQ29uc3RydWN0b3IgRnVuY3Rpb24gdGhhdCB3aWxsIGJlIGNhbGxlZCB0aGUgZmlyc3QgdGltZSB0aGUgdGFnXG4gKiBmb3IgYSBnaXZlbiBvYmplY3QgaXMgcmVxdWVzdGVkLlxuICogQHJldHVybnMgVGhlIHRhZyBkYXRhIGFzc29jaWF0ZWQgd2l0aCB0aGUgdGFyZ2V0IG9iamVjdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRhZzxUYXJnZXQgZXh0ZW5kcyBvYmplY3QsIFRhZ0RhdGE+KFxuICB0YWdEYXRhQ29uc3RydWN0b3I6ICh0YXJnZXQ6IFRhcmdldCkgPT4gVGFnRGF0YVxuKToge1xuICBmb3IodGFyZ2V0OiBUYXJnZXQpOiBUYWdEYXRhXG59IHtcbiAgY29uc3QgbWFwID0gbmV3IFdlYWtNYXA8VGFyZ2V0LCBUYWdEYXRhPigpXG5cbiAgcmV0dXJuIHtcbiAgICBmb3IodGFyZ2V0KTogVGFnRGF0YSB7XG4gICAgICBpZiAoIW1hcC5oYXModGFyZ2V0KSkge1xuICAgICAgICBjb25zdCBkYXRhID0gdGFnRGF0YUNvbnN0cnVjdG9yKHRhcmdldClcbiAgICAgICAgbWFwLnNldCh0YXJnZXQsIGRhdGEpXG4gICAgICAgIHJldHVybiBkYXRhXG4gICAgICB9IGVsc2Uge1xuICAgICAgICByZXR1cm4gbWFwLmdldCh0YXJnZXQpIVxuICAgICAgfVxuICAgIH0sXG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiYUFXRTtRQUlNLDBCQUFVO1NBRVQ7QUFBQSxJQUNMLElBQUk7VUFDRSxDQUFDLElBQUksSUFBSSxNQUFNLEdBQUc7Y0FDZCxPQUFPLG1CQUFtQixNQUFNO1lBQ2xDLElBQUksUUFBUSxJQUFJO2VBQ2I7QUFBQSxhQUNGO2VBQ0UsSUFBSSxJQUFJLE1BQU07QUFBQTs7O0FBSTdCOzsifQ==

package/dist/src/wrappers/ArraySet.mjs

@@ -0,0 +1,85 @@
+import { __decorate } from "../../_virtual/_tslib.mjs";
+import { values } from "mobx";
+import { modelAction } from "../action/modelAction.mjs";
+import { modelIdKey } from "../model/metadata.mjs";
+import { Model } from "../model/Model.mjs";
+import { model } from "../modelShared/modelDecorator.mjs";
+import { idProp } from "../modelShared/prop.mjs";
+import { typesArray } from "../types/arrayBased/array.mjs";
+import { tProp } from "../types/tProp.mjs";
+import { typesUnchecked } from "../types/utility/unchecked.mjs";
+import { namespace } from "../utils/index.mjs";
+let ArraySet = class ArraySet2 extends Model({
+  [modelIdKey]: idProp,
+  items: tProp(typesArray(typesUnchecked()), () => [])
+}) {
+  add(value) {
+    const items = this.items;
+    if (!items.includes(value)) {
+      items.push(value);
+    }
+    return this;
+  }
+  clear() {
+    this.items.length = 0;
+  }
+  delete(value) {
+    const items = this.items;
+    const index = items.findIndex((t) => t === value);
+    if (index >= 0) {
+      items.splice(index, 1);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  forEach(callbackfn, thisArg) {
+    const items = this.items;
+    const len = items.length;
+    for (let i = 0; i < len; i++) {
+      const k = items[i];
+      callbackfn.call(thisArg, k, k, this);
+    }
+  }
+  has(value) {
+    return this.items.includes(value);
+  }
+  get size() {
+    return this.items.length;
+  }
+  keys() {
+    return this.values();
+  }
+  values() {
+    const items = this.items;
+    return values(items)[Symbol.iterator]();
+  }
+  entries() {
+    const items = this.items;
+    return items.map((v) => [v, v]).values();
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  get [Symbol.toStringTag]() {
+    return "ArraySet";
+  }
+};
+__decorate([
+  modelAction
+], ArraySet.prototype, "add", null);
+__decorate([
+  modelAction
+], ArraySet.prototype, "clear", null);
+__decorate([
+  modelAction
+], ArraySet.prototype, "delete", null);
+ArraySet = __decorate([
+  model(`${namespace}/ArraySet`)
+], ArraySet);
+function arraySet(values2) {
+  const initialArr = values2 ? values2.slice() : [];
+  return new ArraySet({ items: initialArr });
+}
+export { ArraySet, arraySet };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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