mobx-keystone 0.68.0 → 0.68.1-alpha

package/dist/src/modelShared/prop.mjs

@@ -0,0 +1,138 @@
+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 prop2 in b || (b = {}))
+    if (__hasOwnProp.call(b, prop2))
+      __defNormalProp(a, prop2, b[prop2]);
+  if (__getOwnPropSymbols)
+    for (var prop2 of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop2))
+        __defNormalProp(a, prop2, b[prop2]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { getOrCreate } from "../utils/mapUtils.mjs";
+const noDefaultValue = Symbol("noDefaultValue");
+const idProp = {
+  _internal: {
+    setter: false,
+    isId: true
+  },
+  withSetter(mode) {
+    return __spreadProps(__spreadValues({}, this), { _internal: __spreadProps(__spreadValues({}, this._internal), { setter: mode != null ? mode : true }) });
+  }
+};
+function prop(def) {
+  let hasDefaultValue = false;
+  if (arguments.length >= 1) {
+    hasDefaultValue = true;
+  }
+  const isDefFn = typeof def === "function";
+  const obj = {
+    _internal: {
+      $valueType: null,
+      $creationValueType: null,
+      $transformedValueType: null,
+      $transformedCreationValueType: null,
+      $isRequired: null,
+      $isId: null,
+      $hasSetter: null,
+      $fromSnapshotOverride: null,
+      $toSnapshotOverride: null,
+      defaultFn: hasDefaultValue && isDefFn ? def : noDefaultValue,
+      defaultValue: hasDefaultValue && !isDefFn ? def : noDefaultValue,
+      typeChecker: void 0,
+      setter: false,
+      isId: false,
+      transform: void 0,
+      fromSnapshotProcessor: void 0,
+      toSnapshotProcessor: void 0
+    },
+    withSetter(mode) {
+      return __spreadProps(__spreadValues({}, this), { _internal: __spreadProps(__spreadValues({}, this._internal), { setter: mode != null ? mode : true }) });
+    },
+    withTransform(transform) {
+      return __spreadProps(__spreadValues({}, this), { _internal: __spreadProps(__spreadValues({}, this._internal), { transform: toFullTransform(transform) }) });
+    },
+    withSnapshotProcessor({ fromSnapshot, toSnapshot }) {
+      let newFromSnapshot;
+      if (this._internal.fromSnapshotProcessor && fromSnapshot) {
+        const oldFn = this._internal.fromSnapshotProcessor;
+        const newFn = fromSnapshot;
+        newFromSnapshot = (sn) => oldFn(newFn(sn));
+      } else if (fromSnapshot) {
+        newFromSnapshot = fromSnapshot;
+      } else {
+        newFromSnapshot = this._internal.fromSnapshotProcessor;
+      }
+      let newToSnapshot;
+      if (this._internal.toSnapshotProcessor && toSnapshot) {
+        const oldFn = this._internal.toSnapshotProcessor;
+        const newFn = toSnapshot;
+        newToSnapshot = (sn) => newFn(oldFn(sn));
+      } else if (toSnapshot) {
+        newToSnapshot = toSnapshot;
+      } else {
+        newToSnapshot = this._internal.toSnapshotProcessor;
+      }
+      return __spreadProps(__spreadValues({}, this), {
+        _internal: __spreadProps(__spreadValues({}, this._internal), {
+          fromSnapshotProcessor: newFromSnapshot,
+          toSnapshotProcessor: newToSnapshot
+        })
+      });
+    }
+  };
+  return obj;
+}
+let cacheTransformResult = false;
+const cacheTransformedValueFn = () => {
+  cacheTransformResult = true;
+};
+function toFullTransform(transformObject) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const transform = (params) => params.originalValue == null ? params.originalValue : transformObject.transform(params);
+  const untransform = (params) => params.transformedValue == null ? params.transformedValue : transformObject.untransform(params);
+  return {
+    transform(originalValue, model, propName, setOriginalValue) {
+      const modelCache = getOrCreate(cache, model, () => /* @__PURE__ */ new Map());
+      let propCache = modelCache.get(propName);
+      if ((propCache == null ? void 0 : propCache.originalValue) !== originalValue) {
+        modelCache.delete(propName);
+        propCache = void 0;
+      }
+      const transformedValue = transform({
+        originalValue,
+        cachedTransformedValue: propCache == null ? void 0 : propCache.transformedValue,
+        setOriginalValue
+      });
+      modelCache.set(propName, {
+        originalValue,
+        transformedValue
+      });
+      return transformedValue;
+    },
+    untransform(transformedValue, model, propName) {
+      const modelCache = getOrCreate(cache, model, () => /* @__PURE__ */ new Map());
+      cacheTransformResult = false;
+      const originalValue = untransform({
+        transformedValue,
+        cacheTransformedValue: cacheTransformedValueFn
+      });
+      if (cacheTransformResult) {
+        modelCache.set(propName, { originalValue, transformedValue });
+      } else {
+        modelCache.delete(propName);
+      }
+      return originalValue;
+    }
+  };
+}
+export { idProp, noDefaultValue, prop };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"prop.mjs","sources":["../../../src/modelShared/prop.ts"],"sourcesContent":["import type { SnapshotInOf, SnapshotOutOf } from \"../snapshot/SnapshotOf\"\nimport type { LateTypeChecker, TypeChecker } from \"../types/TypeChecker\"\nimport { getOrCreate } from \"../utils/mapUtils\"\nimport type { Flatten, IsNeverType, IsOptionalValue } from \"../utils/types\"\n\n/**\n * @ignore\n */\nexport const noDefaultValue = Symbol(\"noDefaultValue\")\n\n/**\n * A model property.\n */\nexport interface ModelProp<\n  TPropValue,\n  TPropCreationValue,\n  TTransformedValue,\n  TTransformedCreationValue,\n  TIsRequired,\n  TIsId extends boolean = false,\n  THasSetter = never,\n  TFromSnapshotOverride = never,\n  TToSnapshotOverride = never\n> {\n  _internal: {\n    $valueType: TPropValue\n    $creationValueType: TPropCreationValue\n    $transformedValueType: TTransformedValue\n    $transformedCreationValueType: TTransformedCreationValue\n    $isRequired: TIsRequired\n    $isId: TIsId\n    $hasSetter: THasSetter\n    $fromSnapshotOverride: TFromSnapshotOverride\n    $toSnapshotOverride: TToSnapshotOverride\n\n    defaultFn: (() => TPropValue) | typeof noDefaultValue\n    defaultValue: TPropValue | typeof noDefaultValue\n    typeChecker: TypeChecker | LateTypeChecker | undefined\n    setter: boolean | \"assign\"\n    isId: boolean\n    transform:\n      | {\n          transform(\n            original: unknown,\n            model: object,\n            propName: PropertyKey,\n            setOriginalValue: (newOriginalValue: unknown) => void\n          ): unknown\n          untransform(transformed: unknown, model: object, propName: PropertyKey): unknown\n        }\n      | undefined\n    fromSnapshotProcessor?(sn: unknown): unknown\n    toSnapshotProcessor?(sn: unknown): unknown\n  }\n\n  withSetter(): ModelProp<\n    TPropValue,\n    TPropCreationValue,\n    TTransformedValue,\n    TTransformedCreationValue,\n    TIsRequired,\n    TIsId,\n    string,\n    TFromSnapshotOverride,\n    TToSnapshotOverride\n  >\n  /**\n   * @deprecated Setter methods are preferred.\n   */\n  withSetter(\n    mode: \"assign\"\n  ): ModelProp<\n    TPropValue,\n    TPropCreationValue,\n    TTransformedValue,\n    TTransformedCreationValue,\n    TIsRequired,\n    TIsId,\n    string,\n    TFromSnapshotOverride,\n    TToSnapshotOverride\n  >\n\n  /**\n   * Sets a transform for the property instance value.\n   *\n   * @typeparam TTV Transformed value type.\n   * @param transform Transform to be used.\n   * @returns\n   */\n  withTransform<TTV>(\n    transform: ModelPropTransform<NonNullable<TPropValue>, TTV>\n  ): ModelProp<\n    TPropValue,\n    TPropCreationValue,\n    TTV | Extract<TPropValue, null | undefined>,\n    TTV | Extract<TPropCreationValue, null | undefined>,\n    TIsRequired,\n    TIsId,\n    THasSetter,\n    TFromSnapshotOverride,\n    TToSnapshotOverride\n  >\n\n  withSnapshotProcessor<\n    FS = TFromSnapshotOverride,\n    TS = TToSnapshotOverride,\n    This extends AnyModelProp = this\n  >(processor: {\n    fromSnapshot?(sn: FS): ModelPropFromSnapshot<This>\n    toSnapshot?(sn: ModelPropToSnapshot<This>): TS\n  }): ModelProp<\n    TPropValue,\n    TPropCreationValue,\n    TTransformedValue,\n    TTransformedCreationValue,\n    TIsRequired,\n    TIsId,\n    THasSetter,\n    FS,\n    TS\n  >\n}\n\n/**\n * The snapshot in type of a model property.\n */\nexport type ModelPropFromSnapshot<MP extends AnyModelProp> = IsNeverType<\n  MP[\"_internal\"][\"$fromSnapshotOverride\"],\n  SnapshotInOf<MP[\"_internal\"][\"$creationValueType\"]>,\n  MP[\"_internal\"][\"$fromSnapshotOverride\"]\n>\n\n/**\n * The snapshot out type of a model property.\n */\nexport type ModelPropToSnapshot<MP extends AnyModelProp> = IsNeverType<\n  MP[\"_internal\"][\"$toSnapshotOverride\"],\n  SnapshotOutOf<MP[\"_internal\"][\"$valueType\"]>,\n  MP[\"_internal\"][\"$toSnapshotOverride\"]\n>\n\n/**\n * A model prop transform.\n */\nexport interface ModelPropTransform<TOriginal, TTransformed> {\n  transform(params: {\n    originalValue: TOriginal\n    cachedTransformedValue: TTransformed | undefined\n    setOriginalValue(value: TOriginal): void\n  }): TTransformed\n\n  untransform(params: { transformedValue: TTransformed; cacheTransformedValue(): void }): TOriginal\n}\n\n/**\n * Any model property.\n */\nexport type AnyModelProp = ModelProp<any, any, any, any, any, any, any, any, any>\n\n/**\n * Model properties.\n */\nexport interface ModelProps {\n  [k: string]: AnyModelProp\n}\n\nexport type RequiredModelProps<MP extends ModelProps> = {\n  [K in keyof MP]: MP[K][\"_internal\"][\"$isRequired\"] & K\n}[keyof MP]\n\nexport type ModelPropsToData<MP extends ModelProps> = Flatten<{\n  [k in keyof MP]: MP[k][\"_internal\"][\"$valueType\"]\n}>\n\nexport type ModelPropsToSnapshotData<MP extends ModelProps> = Flatten<{\n  [k in keyof MP]: ModelPropToSnapshot<MP[k]> extends infer R ? R : never\n}>\n\n// we don't use O.Optional anymore since it generates unions too heavy\n// also if we use pick over the optional props we will loose the ability\n// to infer generics\n// we also don't use Flatten because if we do some generics won't work\nexport type ModelPropsToCreationData<MP extends ModelProps> = {\n  [k in keyof MP]?: MP[k][\"_internal\"][\"$creationValueType\"]\n} & {\n  [k in RequiredModelProps<MP>]: MP[k][\"_internal\"][\"$creationValueType\"]\n}\n\n// we don't use O.Optional anymore since it generates unions too heavy\n// also if we use pick over the optional props we will loose the ability\n// to infer generics\nexport type ModelPropsToSnapshotCreationData<MP extends ModelProps> = Flatten<\n  {\n    [k in keyof MP]?: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never\n  } & {\n    [k in {\n      [K in keyof MP]: IsNeverType<\n        MP[K][\"_internal\"][\"$fromSnapshotOverride\"],\n        MP[K][\"_internal\"][\"$isRequired\"] & K, // no override\n        IsOptionalValue<MP[K][\"_internal\"][\"$fromSnapshotOverride\"], never, K> // with override\n      >\n    }[keyof MP]]: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never\n  }\n>\n\nexport type ModelPropsToTransformedData<MP extends ModelProps> = Flatten<{\n  [k in keyof MP]: MP[k][\"_internal\"][\"$transformedValueType\"]\n}>\n\n// we don't use O.Optional anymore since it generates unions too heavy\n// also if we use pick over the optional props we will loose the ability\n// to infer generics\n// we also don't use Flatten because if we do some generics won't work\n// we also don't use Omit because if we do some generics won't work\nexport type ModelPropsToTransformedCreationData<MP extends ModelProps> = {\n  [k in keyof MP]?: MP[k][\"_internal\"][\"$transformedCreationValueType\"]\n} & {\n  [k in RequiredModelProps<MP>]: MP[k][\"_internal\"][\"$transformedCreationValueType\"]\n}\n\nexport type ModelPropsToSetter<MP extends ModelProps> = Flatten<{\n  [k in keyof MP as MP[k][\"_internal\"][\"$hasSetter\"] & `set${Capitalize<k & string>}`]: (\n    value: MP[k][\"_internal\"][\"$transformedValueType\"]\n  ) => void\n}>\n\nexport type ModelIdProp = ModelProp<\n  string,\n  string | undefined,\n  string,\n  string | undefined,\n  never, // not required\n  true\n>\n\n/**\n * A property that will be used as model id, accessible through $modelId.\n * Can only be used in models and there can be only one per model.\n */\nexport const idProp = {\n  _internal: {\n    setter: false,\n    isId: true,\n  },\n\n  withSetter(mode?: boolean | \"assign\") {\n    return { ...this, _internal: { ...this._internal, setter: mode ?? true } }\n  },\n} as any as ModelIdProp\n\n/**\n * @ignore\n */\nexport type OnlyPrimitives<T> = Exclude<T, object>\n\n/**\n * A model prop that maybe / maybe not is optional, depending on if the value can take undefined.\n */\nexport type MaybeOptionalModelProp<TPropValue> = ModelProp<\n  TPropValue,\n  TPropValue,\n  TPropValue,\n  TPropValue,\n  IsOptionalValue<TPropValue, never, string> // calculate if required\n>\n\n/**\n * A model prop that is definitely optional.\n */\nexport type OptionalModelProp<TPropValue> = ModelProp<\n  TPropValue,\n  TPropValue | null | undefined,\n  TPropValue,\n  TPropValue | null | undefined,\n  never // not required\n>\n\n/**\n * Defines a model property, with an optional function to generate a default value\n * if the input snapshot / model creation data is `null` or `undefined`.\n *\n * Example:\n * ```ts\n * x: prop(() => 10) // an optional number, with a default value of 10\n * x: prop<number[]>(() => []) // an optional number array, with a default empty array\n * ```\n *\n * @typeparam TValue Value type.\n * @param defaultFn Default value generator function.\n * @returns\n */\nexport function prop<TValue>(defaultFn: () => TValue): OptionalModelProp<TValue>\n\n/**\n * Defines a model property, with an optional default value\n * if the input snapshot / model creation data is `null` or `undefined`.\n * You should only use this with primitive values and never with object values\n * (array, model, object, etc).\n *\n * Example:\n * ```ts\n * x: prop(10) // an optional number, with a default value of 10\n * ```\n *\n * @typeparam TValue Value type.\n * @param defaultValue Default primitive value.\n * @returns\n */\nexport function prop<TValue>(defaultValue: OnlyPrimitives<TValue>): OptionalModelProp<TValue>\n\n/**\n * Defines a model property with no default value.\n *\n * Example:\n * ```ts\n * x: prop<number>() // a required number\n * x: prop<number | undefined>() // an optional number, which defaults to undefined\n * ```\n *\n * @typeparam TValue Value type.\n * @returns\n */\nexport function prop<TValue>(): MaybeOptionalModelProp<TValue>\n\n// base\nexport function prop(def?: any): AnyModelProp {\n  let hasDefaultValue = false\n\n  // default\n  if (arguments.length >= 1) {\n    hasDefaultValue = true\n  }\n\n  const isDefFn = typeof def === \"function\"\n\n  const obj: AnyModelProp = {\n    _internal: {\n      $valueType: null as any,\n      $creationValueType: null as any,\n      $transformedValueType: null as any,\n      $transformedCreationValueType: null as any,\n      $isRequired: null as never,\n      $isId: null as never,\n      $hasSetter: null as never,\n      $fromSnapshotOverride: null as never,\n      $toSnapshotOverride: null as never,\n\n      defaultFn: hasDefaultValue && isDefFn ? def : noDefaultValue,\n      defaultValue: hasDefaultValue && !isDefFn ? def : noDefaultValue,\n      typeChecker: undefined,\n      setter: false,\n      isId: false,\n      transform: undefined,\n      fromSnapshotProcessor: undefined,\n      toSnapshotProcessor: undefined,\n    },\n\n    withSetter(mode?: boolean | \"assign\") {\n      return { ...this, _internal: { ...this._internal, setter: mode ?? true } }\n    },\n\n    withTransform(transform: ModelPropTransform<unknown, unknown>) {\n      return { ...this, _internal: { ...this._internal, transform: toFullTransform(transform) } }\n    },\n\n    withSnapshotProcessor({ fromSnapshot, toSnapshot }) {\n      let newFromSnapshot\n\n      if (this._internal.fromSnapshotProcessor && fromSnapshot) {\n        const oldFn = this._internal.fromSnapshotProcessor\n        const newFn = fromSnapshot\n        newFromSnapshot = (sn: any) => oldFn(newFn(sn))\n      } else if (fromSnapshot) {\n        newFromSnapshot = fromSnapshot\n      } else {\n        newFromSnapshot = this._internal.fromSnapshotProcessor\n      }\n\n      let newToSnapshot\n\n      if (this._internal.toSnapshotProcessor && toSnapshot) {\n        const oldFn: any = this._internal.toSnapshotProcessor\n        const newFn = toSnapshot\n        newToSnapshot = (sn: any) => newFn(oldFn(sn))\n      } else if (toSnapshot) {\n        newToSnapshot = toSnapshot\n      } else {\n        newToSnapshot = this._internal.toSnapshotProcessor\n      }\n\n      return {\n        ...this,\n        _internal: {\n          ...this._internal,\n          fromSnapshotProcessor: newFromSnapshot,\n          toSnapshotProcessor: newToSnapshot,\n        },\n      }\n    },\n  }\n\n  return obj\n}\n\nlet cacheTransformResult = false\nconst cacheTransformedValueFn = () => {\n  cacheTransformResult = true\n}\n\nfunction toFullTransform(transformObject: ModelPropTransform<unknown, unknown>) {\n  const cache = new WeakMap<\n    object,\n    Map<PropertyKey, { originalValue: unknown; transformedValue: unknown }>\n  >()\n\n  const transform = (params: {\n    originalValue: unknown\n    cachedTransformedValue: unknown\n    setOriginalValue(newOriginalValue: unknown): void\n  }) => (params.originalValue == null ? params.originalValue : transformObject.transform(params))\n\n  const untransform = (params: { transformedValue: unknown; cacheTransformedValue(): void }) =>\n    params.transformedValue == null ? params.transformedValue : transformObject.untransform(params)\n\n  return {\n    transform(\n      originalValue: unknown,\n      model: object,\n      propName: PropertyKey,\n      setOriginalValue: (newOriginalValue: unknown) => void\n    ) {\n      const modelCache = getOrCreate(cache, model, () => new Map())\n\n      let propCache = modelCache.get(propName)\n      if (propCache?.originalValue !== originalValue) {\n        // original changed, invalidate cache\n        modelCache.delete(propName)\n        propCache = undefined\n      }\n\n      const transformedValue = transform({\n        originalValue,\n        cachedTransformedValue: propCache?.transformedValue,\n        setOriginalValue,\n      })\n\n      modelCache.set(propName, {\n        originalValue,\n        transformedValue,\n      })\n\n      return transformedValue\n    },\n\n    untransform(transformedValue: unknown, model: object, propName: PropertyKey) {\n      const modelCache = getOrCreate(cache, model, () => new Map())\n\n      cacheTransformResult = false\n      const originalValue = untransform({\n        transformedValue,\n        cacheTransformedValue: cacheTransformedValueFn,\n      })\n      if (cacheTransformResult) {\n        modelCache.set(propName, { originalValue, transformedValue })\n      } else {\n        modelCache.delete(propName)\n      }\n\n      return originalValue\n    },\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;MAQa,iBAAiB,OAAO,gBAAgB;MAwOxC,SAAS;AAAA,EACpB,WAAW;AAAA,IACT,QAAQ;AAAA,IACR,MAAM;AAAA;EAGR,WAAW;WACF,iCAAK,OAAL,EAAW,WAAW,iCAAK,KAAK,YAAV,EAAqB,QAAQ,sBAAQ;;;cA+EjD;MACf,kBAAkB;MAGlB,UAAU,UAAU,GAAG;sBACP;AAAA;QAGd,UAAU,OAAO,QAAQ;QAEzB,MAAoB;AAAA,IACxB,WAAW;AAAA,MACT,YAAY;AAAA,MACZ,oBAAoB;AAAA,MACpB,uBAAuB;AAAA,MACvB,+BAA+B;AAAA,MAC/B,aAAa;AAAA,MACb,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,uBAAuB;AAAA,MACvB,qBAAqB;AAAA,MAErB,WAAW,mBAAmB,UAAU,MAAM;AAAA,MAC9C,cAAc,mBAAmB,CAAC,UAAU,MAAM;AAAA,MAClD,aAAa;AAAA,MACb,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,WAAW;AAAA,MACX,uBAAuB;AAAA,MACvB,qBAAqB;AAAA;IAGvB,WAAW;aACF,iCAAK,OAAL,EAAW,WAAW,iCAAK,KAAK,YAAV,EAAqB,QAAQ,sBAAQ;;IAGpE,cAAc;aACL,iCAAK,OAAL,EAAW,WAAW,iCAAK,KAAK,YAAV,EAAqB,WAAW,gBAAgB,SAAS;;IAGxF,sBAAsB,EAAE,cAAc;UAChC;UAEA,KAAK,UAAU,yBAAyB,cAAc;cAClD,QAAQ,KAAK,UAAU;cACvB,QAAQ;0BACI,CAAC,OAAY,MAAM,MAAM,EAAE,CAAC;AAAA,iBACrC,cAAc;0BACL;AAAA,aACb;0BACa,KAAK,UAAU;AAAA;UAG/B;UAEA,KAAK,UAAU,uBAAuB,YAAY;cAC9C,QAAa,KAAK,UAAU;cAC5B,QAAQ;wBACE,CAAC,OAAY,MAAM,MAAM,EAAE,CAAC;AAAA,iBACnC,YAAY;wBACL;AAAA,aACX;wBACW,KAAK,UAAU;AAAA;aAG1B,iCACF,OADE;AAAA,QAEL,WAAW,iCACN,KAAK,YADC;AAAA,UAET,uBAAuB;AAAA,UACvB,qBAAqB;AAAA;;;;SAMtB;AACT;AAEA,IAAI,uBAAuB;AAC3B,MAAM,0BAA0B;yBACP;AACzB;AAEA,yBAAyB;QACjB,4BAAY;QAKZ,YAAY,CAAC,WAIZ,OAAO,iBAAiB,OAAO,OAAO,gBAAgB,gBAAgB,UAAU,MAAM;QAEvF,cAAc,CAAC,WACnB,OAAO,oBAAoB,OAAO,OAAO,mBAAmB,gBAAgB,YAAY,MAAM;SAEzF;AAAA,IACL,UACE,eACA,OACA,UACA;YAEM,aAAa,YAAY,OAAO,OAAO,0BAAU,KAAK;UAExD,YAAY,WAAW,IAAI,QAAQ;UACnC,wCAAW,mBAAkB,eAAe;mBAEnC,OAAO,QAAQ;oBACd;AAAA;YAGR,mBAAmB,UAAU;AAAA,QACjC;AAAA,QACA,wBAAwB,uCAAW;AAAA,QACnC;AAAA,OACD;iBAEU,IAAI,UAAU;AAAA,QACvB;AAAA,QACA;AAAA,OACD;aAEM;AAAA;IAGT,YAAY,kBAA2B,OAAe;YAC9C,aAAa,YAAY,OAAO,OAAO,0BAAU,KAAK;6BAErC;YACjB,gBAAgB,YAAY;AAAA,QAChC;AAAA,QACA,uBAAuB;AAAA,OACxB;UACG,sBAAsB;mBACb,IAAI,UAAU,EAAE,eAAe,kBAAkB;AAAA,aACvD;mBACM,OAAO,QAAQ;AAAA;aAGrB;AAAA;;AAGb;;"}

package/dist/src/modelShared/utils.mjs

@@ -0,0 +1,10 @@
+import { isDataModelClass } from "../dataModel/utils.mjs";
+import { isModelClass } from "../model/utils.mjs";
+import { failure } from "../utils/index.mjs";
+function assertIsClassOrDataModelClass(model, argName, customErrMsg = "must be a class or data model class") {
+  if (!isModelClass(model) && !isDataModelClass(model)) {
+    throw failure(`${argName} ${customErrMsg}`);
+  }
+}
+export { assertIsClassOrDataModelClass };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWxTaGFyZWQvdXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBBbnlEYXRhTW9kZWwgfSBmcm9tIFwiLi4vZGF0YU1vZGVsL0Jhc2VEYXRhTW9kZWxcIlxuaW1wb3J0IHsgaXNEYXRhTW9kZWxDbGFzcyB9IGZyb20gXCIuLi9kYXRhTW9kZWwvdXRpbHNcIlxuaW1wb3J0IHR5cGUgeyBBbnlNb2RlbCB9IGZyb20gXCIuLi9tb2RlbC9CYXNlTW9kZWxcIlxuaW1wb3J0IHsgaXNNb2RlbENsYXNzIH0gZnJvbSBcIi4uL21vZGVsL3V0aWxzXCJcbmltcG9ydCB7IGZhaWx1cmUgfSBmcm9tIFwiLi4vdXRpbHNcIlxuaW1wb3J0IHR5cGUgeyBNb2RlbENsYXNzIH0gZnJvbSBcIi4vQmFzZU1vZGVsU2hhcmVkXCJcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqXG4gKiBBc3NlcnRzIHNvbWV0aGluZyBpcyBhY3R1YWxseSBhIGNsYXNzIG9yIGRhdGEgbW9kZWwuXG4gKlxuICogQHBhcmFtIG1vZGVsXG4gKiBAcGFyYW0gYXJnTmFtZVxuICovXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0SXNDbGFzc09yRGF0YU1vZGVsQ2xhc3MoXG4gIG1vZGVsOiB1bmtub3duLFxuICBhcmdOYW1lOiBzdHJpbmcsXG4gIGN1c3RvbUVyck1zZyA9IFwibXVzdCBiZSBhIGNsYXNzIG9yIGRhdGEgbW9kZWwgY2xhc3NcIlxuKTogYXNzZXJ0cyBtb2RlbCBpcyBNb2RlbENsYXNzPEFueU1vZGVsPiB8IE1vZGVsQ2xhc3M8QW55RGF0YU1vZGVsPiB7XG4gIGlmICghaXNNb2RlbENsYXNzKG1vZGVsKSAmJiAhaXNEYXRhTW9kZWxDbGFzcyhtb2RlbCkpIHtcbiAgICB0aHJvdyBmYWlsdXJlKGAke2FyZ05hbWV9ICR7Y3VzdG9tRXJyTXNnfWApXG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7dUNBZ0JFLE9BQ0EsU0FDQSxlQUFlO01BRVgsQ0FBQyxhQUFhLEtBQUssS0FBSyxDQUFDLGlCQUFpQixLQUFLLEdBQUc7VUFDOUMsUUFBUSxHQUFHLFdBQVcsY0FBYztBQUFBO0FBRTlDOzsifQ==

package/dist/src/parent/core.mjs

@@ -0,0 +1,34 @@
+import { createAtom } from "mobx";
+import { isModel } from "../model/utils.mjs";
+import { getOrCreate } from "../utils/mapUtils.mjs";
+const objectParents = /* @__PURE__ */ new WeakMap();
+const objectParentsAtoms = /* @__PURE__ */ new WeakMap();
+function parentPathEquals(parentPath1, parentPath2, comparePath = true) {
+  if (!parentPath1 && !parentPath2)
+    return true;
+  if (!parentPath1 || !parentPath2)
+    return false;
+  const parentEquals = parentPath1.parent === parentPath2.parent;
+  if (!parentEquals)
+    return false;
+  return comparePath ? parentPath1.path === parentPath2.path : true;
+}
+function createParentPathAtom(obj) {
+  return getOrCreate(objectParentsAtoms, obj, () => createAtom("parentAtom"));
+}
+function reportParentPathObserved(node) {
+  createParentPathAtom(node).reportObserved();
+}
+function reportParentPathChanged(node) {
+  createParentPathAtom(node).reportChanged();
+}
+const dataObjectParent = /* @__PURE__ */ new WeakMap();
+function dataToModelNode(node) {
+  const modelNode = dataObjectParent.get(node);
+  return modelNode != null ? modelNode : node;
+}
+function modelToDataNode(node) {
+  return isModel(node) ? node.$ : node;
+}
+export { dataObjectParent, dataToModelNode, modelToDataNode, objectParents, parentPathEquals, reportParentPathChanged, reportParentPathObserved };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/parent/coreObjectChildren.mjs

@@ -0,0 +1,98 @@
+import { action, observable, createAtom } from "mobx";
+import { fastGetParent } from "./path.mjs";
+const defaultObservableSetOptions = { deep: false };
+const objectChildren = /* @__PURE__ */ new WeakMap();
+function initializeObjectChildren(node) {
+  if (objectChildren.has(node)) {
+    return;
+  }
+  objectChildren.set(node, {
+    shallow: observable.set(void 0, defaultObservableSetOptions),
+    deep: /* @__PURE__ */ new Set(),
+    extensionsData: initExtensionsData(),
+    deepDirty: true,
+    deepAtom: createAtom("deepChildrenAtom")
+  });
+}
+function getObjectChildren(node) {
+  return objectChildren.get(node).shallow;
+}
+function getDeepObjectChildren(node) {
+  const obj = objectChildren.get(node);
+  if (obj.deepDirty) {
+    updateDeepObjectChildren(node);
+  }
+  obj.deepAtom.reportObserved();
+  return obj;
+}
+function addNodeToDeepLists(node, data) {
+  data.deep.add(node);
+  extensions.forEach((extension, dataSymbol) => {
+    extension.addNode(node, data.extensionsData.get(dataSymbol));
+  });
+}
+const updateDeepObjectChildren = action((node) => {
+  const obj = objectChildren.get(node);
+  if (!obj.deepDirty) {
+    return obj;
+  }
+  const data = {
+    deep: /* @__PURE__ */ new Set(),
+    extensionsData: initExtensionsData()
+  };
+  const childrenIter = getObjectChildren(node).values();
+  let ch = childrenIter.next();
+  while (!ch.done) {
+    addNodeToDeepLists(ch.value, data);
+    const ret = updateDeepObjectChildren(ch.value).deep;
+    const retIter = ret.values();
+    let retCur = retIter.next();
+    while (!retCur.done) {
+      addNodeToDeepLists(retCur.value, data);
+      retCur = retIter.next();
+    }
+    ch = childrenIter.next();
+  }
+  Object.assign(obj, data);
+  obj.deepDirty = false;
+  obj.deepAtom.reportChanged();
+  return obj;
+});
+const addObjectChild = action((node, child) => {
+  const obj = objectChildren.get(node);
+  obj.shallow.add(child);
+  invalidateDeepChildren(node);
+});
+const removeObjectChild = action((node, child) => {
+  const obj = objectChildren.get(node);
+  obj.shallow.delete(child);
+  invalidateDeepChildren(node);
+});
+function invalidateDeepChildren(node) {
+  const obj = objectChildren.get(node);
+  if (!obj.deepDirty) {
+    obj.deepDirty = true;
+    obj.deepAtom.reportChanged();
+  }
+  const parent = fastGetParent(node);
+  if (parent) {
+    invalidateDeepChildren(parent);
+  }
+}
+const extensions = /* @__PURE__ */ new Map();
+function registerDeepObjectChildrenExtension(extension) {
+  const dataSymbol = Symbol("deepObjectChildrenExtension");
+  extensions.set(dataSymbol, extension);
+  return (data) => {
+    return data.extensionsData.get(dataSymbol);
+  };
+}
+function initExtensionsData() {
+  const extensionsData = /* @__PURE__ */ new Map();
+  extensions.forEach((extension, dataSymbol) => {
+    extensionsData.set(dataSymbol, extension.initData());
+  });
+  return extensionsData;
+}
+export { addObjectChild, getDeepObjectChildren, getObjectChildren, initializeObjectChildren, registerDeepObjectChildrenExtension, removeObjectChild };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/parent/detach.mjs

@@ -0,0 +1,32 @@
+import { isObservableArray, isObservableObject, remove } from "mobx";
+import { BuiltInAction } from "../action/builtInActions.mjs";
+import { ActionContextActionType } from "../action/context.mjs";
+import { wrapInAction } from "../action/wrapInAction.mjs";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { lazy, failure } from "../utils/index.mjs";
+import { fastGetParentPathIncludingDataObjects } from "./path.mjs";
+function detach(node) {
+  assertTweakedObject(node, "node");
+  wrappedInternalDetach().call(node);
+}
+const wrappedInternalDetach = lazy(() => wrapInAction({
+  nameOrNameFn: BuiltInAction.Detach,
+  fn: internalDetach,
+  actionType: ActionContextActionType.Sync
+}));
+function internalDetach() {
+  const node = this;
+  const parentPath = fastGetParentPathIncludingDataObjects(node);
+  if (!parentPath)
+    return;
+  const { parent, path } = parentPath;
+  if (isObservableArray(parent)) {
+    parent.splice(+path, 1);
+  } else if (isObservableObject(parent)) {
+    remove(parent, "" + path);
+  } else {
+    throw failure("parent must be an observable object or an observable array");
+  }
+}
+export { detach };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/parent/findChildren.mjs

@@ -0,0 +1,16 @@
+import { getChildrenObjects } from "./getChildrenObjects.mjs";
+function findChildren(root, predicate, options) {
+  const children = getChildrenObjects(root, options);
+  const set = /* @__PURE__ */ new Set();
+  const iter = children.values();
+  let cur = iter.next();
+  while (!cur.done) {
+    if (predicate(cur.value)) {
+      set.add(cur.value);
+    }
+    cur = iter.next();
+  }
+  return set;
+}
+export { findChildren };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZENoaWxkcmVuLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3BhcmVudC9maW5kQ2hpbGRyZW4udHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0Q2hpbGRyZW5PYmplY3RzIH0gZnJvbSBcIi4vZ2V0Q2hpbGRyZW5PYmplY3RzXCJcblxuLyoqXG4gKiBJdGVyYXRlcyB0aHJvdWdoIGFsbCBjaGlsZHJlbiBhbmQgY29sbGVjdHMgdGhlbSBpbiBhIHNldCBpZiB0aGVcbiAqIGdpdmVuIHByZWRpY2F0ZSBtYXRjaGVzLlxuICpcbiAqIEBwYXJhbSByb290IFJvb3Qgb2JqZWN0IHRvIGdldCB0aGUgbWF0Y2hpbmcgY2hpbGRyZW4gZnJvbS5cbiAqIEBwYXJhbSBwcmVkaWNhdGUgRnVuY3Rpb24gdGhhdCB3aWxsIGJlIHJ1biBmb3IgZXZlcnkgY2hpbGQgb2YgdGhlIHJvb3Qgb2JqZWN0LlxuICogQHBhcmFtIFtvcHRpb25zXSBBbiBvcHRpb25hbCBvYmplY3Qgd2l0aCB0aGUgYGRlZXBgIG9wdGlvbiAoZGVmYXVsdHMgdG8gYGZhbHNlYCkgc2V0IHRvIGB0cnVlYCB0b1xuICogZ2V0IHRoZSBjaGlsZHJlbiBkZWVwbHkgb3IgYGZhbHNlYCB0byBnZXQgdGhlbSBzaGFsbG93bHkuXG4gKiBAcmV0dXJucyBBIHJlYWRvbmx5IG9ic2VydmFibGUgc2V0IHdpdGggdGhlIG1hdGNoaW5nIGNoaWxkcmVuLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZmluZENoaWxkcmVuPFQgZXh0ZW5kcyBvYmplY3QgPSBhbnk+KFxuICByb290OiBvYmplY3QsXG4gIHByZWRpY2F0ZTogKG5vZGU6IG9iamVjdCkgPT4gYm9vbGVhbixcbiAgb3B0aW9ucz86IHtcbiAgICBkZWVwPzogYm9vbGVhblxuICB9XG4pOiBSZWFkb25seVNldDxUPiB7XG4gIGNvbnN0IGNoaWxkcmVuID0gZ2V0Q2hpbGRyZW5PYmplY3RzKHJvb3QsIG9wdGlvbnMpXG5cbiAgY29uc3Qgc2V0ID0gbmV3IFNldDxhbnk+KClcblxuICBjb25zdCBpdGVyID0gY2hpbGRyZW4udmFsdWVzKClcbiAgbGV0IGN1ciA9IGl0ZXIubmV4dCgpXG4gIHdoaWxlICghY3VyLmRvbmUpIHtcbiAgICBpZiAocHJlZGljYXRlKGN1ci52YWx1ZSkpIHtcbiAgICAgIHNldC5hZGQoY3VyLnZhbHVlKVxuICAgIH1cbiAgICBjdXIgPSBpdGVyLm5leHQoKVxuICB9XG5cbiAgcmV0dXJuIHNldFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7c0JBYUUsTUFDQSxXQUNBO1FBSU0sV0FBVyxtQkFBbUIsTUFBTSxPQUFPO1FBRTNDLDBCQUFVO1FBRVYsT0FBTyxTQUFTO01BQ2xCLE1BQU0sS0FBSztTQUNSLENBQUMsSUFBSSxNQUFNO1FBQ1osVUFBVSxJQUFJLEtBQUssR0FBRztVQUNwQixJQUFJLElBQUksS0FBSztBQUFBO1VBRWIsS0FBSzs7U0FHTjtBQUNUOzsifQ==

package/dist/src/parent/findParent.mjs

@@ -0,0 +1,30 @@
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { fastGetParentPath } from "./path.mjs";
+function findParent(child, predicate, maxDepth = 0) {
+  const foundParentPath = findParentPath(child, predicate, maxDepth);
+  return foundParentPath ? foundParentPath.parent : void 0;
+}
+function findParentPath(child, predicate, maxDepth = 0) {
+  assertTweakedObject(child, "child");
+  const path = [];
+  let current = child;
+  let depth = 0;
+  let parentPath;
+  while (parentPath = fastGetParentPath(current)) {
+    path.unshift(parentPath.path);
+    current = parentPath.parent;
+    if (predicate(current)) {
+      return {
+        parent: current,
+        path
+      };
+    }
+    depth++;
+    if (maxDepth > 0 && depth === maxDepth) {
+      break;
+    }
+  }
+  return void 0;
+}
+export { findParent, findParentPath };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/parent/getChildrenObjects.mjs

@@ -0,0 +1,12 @@
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { getObjectChildren, getDeepObjectChildren } from "./coreObjectChildren.mjs";
+function getChildrenObjects(node, options) {
+  assertTweakedObject(node, "node");
+  if (!options || !options.deep) {
+    return getObjectChildren(node);
+  } else {
+    return getDeepObjectChildren(node).deep;
+  }
+}
+export { getChildrenObjects };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0Q2hpbGRyZW5PYmplY3RzLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3BhcmVudC9nZXRDaGlsZHJlbk9iamVjdHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXNzZXJ0VHdlYWtlZE9iamVjdCB9IGZyb20gXCIuLi90d2Vha2VyL2NvcmVcIlxuaW1wb3J0IHsgZ2V0RGVlcE9iamVjdENoaWxkcmVuLCBnZXRPYmplY3RDaGlsZHJlbiB9IGZyb20gXCIuL2NvcmVPYmplY3RDaGlsZHJlblwiXG5cbi8qKlxuICogUmV0dXJucyBhbGwgdGhlIGNoaWxkcmVuIG9iamVjdHMgKHRoaXMgaXMsIGV4Y2x1ZGluZyBwcmltaXRpdmVzKSBvZiBhbiBvYmplY3QuXG4gKlxuICogQHBhcmFtIG5vZGUgT2JqZWN0IHRvIGdldCB0aGUgbGlzdCBvZiBjaGlsZHJlbiBmcm9tLlxuICogQHBhcmFtIFtvcHRpb25zXSBBbiBvcHRpb25hbCBvYmplY3Qgd2l0aCB0aGUgYGRlZXBgIG9wdGlvbiAoZGVmYXVsdHMgdG8gZmFsc2UpIHRvIHRydWUgdG8gZ2V0XG4gKiB0aGUgY2hpbGRyZW4gZGVlcGx5IG9yIGZhbHNlIHRvIGdldCB0aGVtIHNoYWxsb3dseS5cbiAqIEByZXR1cm5zIEEgcmVhZG9ubHkgb2JzZXJ2YWJsZSBzZXQgd2l0aCB0aGUgY2hpbGRyZW4uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRDaGlsZHJlbk9iamVjdHMoXG4gIG5vZGU6IG9iamVjdCxcbiAgb3B0aW9ucz86IHtcbiAgICBkZWVwPzogYm9vbGVhblxuICB9XG4pOiBSZWFkb25seVNldDxvYmplY3Q+IHtcbiAgYXNzZXJ0VHdlYWtlZE9iamVjdChub2RlLCBcIm5vZGVcIilcblxuICBpZiAoIW9wdGlvbnMgfHwgIW9wdGlvbnMuZGVlcCkge1xuICAgIHJldHVybiBnZXRPYmplY3RDaGlsZHJlbihub2RlKVxuICB9IGVsc2Uge1xuICAgIHJldHVybiBnZXREZWVwT2JqZWN0Q2hpbGRyZW4obm9kZSkuZGVlcFxuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7NEJBWUUsTUFDQTtzQkFJb0IsTUFBTSxNQUFNO01BRTVCLENBQUMsV0FBVyxDQUFDLFFBQVEsTUFBTTtXQUN0QixrQkFBa0IsSUFBSTtBQUFBLFNBQ3hCO1dBQ0Usc0JBQXNCLElBQUksRUFBRTtBQUFBO0FBRXZDOzsifQ==

package/dist/src/parent/onChildAttachedTo.mjs

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import { reaction } from "mobx";
+import { assertTweakedObject } from "../tweaker/core.mjs";
+import { assertIsFunction } from "../utils/index.mjs";
+import { getChildrenObjects } from "./getChildrenObjects.mjs";
+function onChildAttachedTo(target, fn, options) {
+  assertIsFunction(target, "target");
+  assertIsFunction(fn, "fn");
+  const opts = __spreadValues({
+    deep: false,
+    runForCurrentChildren: true
+  }, options);
+  const detachDisposers = /* @__PURE__ */ new WeakMap();
+  const runDetachDisposer = (n) => {
+    const detachDisposer = detachDisposers.get(n);
+    if (detachDisposer) {
+      detachDisposers.delete(n);
+      detachDisposer();
+    }
+  };
+  const addDetachDisposer = (n, disposer2) => {
+    if (disposer2) {
+      detachDisposers.set(n, disposer2);
+    }
+  };
+  const getChildrenObjectOpts = { deep: opts.deep };
+  const getCurrentChildren = () => {
+    let t = target();
+    assertTweakedObject(t, "target()");
+    const children = getChildrenObjects(t, getChildrenObjectOpts);
+    const set = /* @__PURE__ */ new Set();
+    const iter = children.values();
+    let cur = iter.next();
+    while (!cur.done) {
+      set.add(cur.value);
+      cur = iter.next();
+    }
+    return set;
+  };
+  const currentChildren = opts.runForCurrentChildren ? /* @__PURE__ */ new Set() : getCurrentChildren();
+  const disposer = reaction(() => getCurrentChildren(), (newChildren) => {
+    const disposersToRun = [];
+    const currentChildrenIter = currentChildren.values();
+    let currentChildrenCur = currentChildrenIter.next();
+    while (!currentChildrenCur.done) {
+      const n = currentChildrenCur.value;
+      if (!newChildren.has(n)) {
+        currentChildren.delete(n);
+        disposersToRun.push(n);
+      }
+      currentChildrenCur = currentChildrenIter.next();
+    }
+    if (disposersToRun.length > 0) {
+      for (let i = disposersToRun.length - 1; i >= 0; i--) {
+        runDetachDisposer(disposersToRun[i]);
+      }
+    }
+    const newChildrenIter = newChildren.values();
+    let newChildrenCur = newChildrenIter.next();
+    while (!newChildrenCur.done) {
+      const n = newChildrenCur.value;
+      if (!currentChildren.has(n)) {
+        currentChildren.add(n);
+        addDetachDisposer(n, fn(n));
+      }
+      newChildrenCur = newChildrenIter.next();
+    }
+  }, {
+    fireImmediately: true
+  });
+  return (runDetachDisposers) => {
+    disposer();
+    if (runDetachDisposers) {
+      const currentChildrenIter = currentChildren.values();
+      let currentChildrenCur = currentChildrenIter.next();
+      while (!currentChildrenCur.done) {
+        const n = currentChildrenCur.value;
+        runDetachDisposer(n);
+        currentChildrenCur = currentChildrenIter.next();
+      }
+    }
+    currentChildren.clear();
+  };
+}
+export { onChildAttachedTo };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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