@tachybase/schema 0.23.40 → 0.23.47

package/lib/reactive/handlers.js

@@ -0,0 +1,246 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handlers_exports = {};
+__export(handlers_exports, {
+  baseHandlers: () => baseHandlers,
+  collectionHandlers: () => collectionHandlers
+});
+module.exports = __toCommonJS(handlers_exports);
+var import_environment = require("./environment");
+var import_externals = require("./externals");
+var import_internals = require("./internals");
+var import_reaction = require("./reaction");
+const wellKnownSymbols = new Set(
+  Object.getOwnPropertyNames(Symbol).reduce((buf, key) => {
+    if (key === "arguments" || key === "caller") return buf;
+    const value = Symbol[key];
+    if (typeof value === "symbol") return buf.concat(value);
+    return buf;
+  }, [])
+);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function findObservable(target, key, value) {
+  const observableObj = import_environment.RawProxy.get(value);
+  if (observableObj) {
+    return observableObj;
+  }
+  if (!(0, import_externals.isObservable)(value) && (0, import_externals.isSupportObservable)(value)) {
+    return (0, import_internals.createObservable)(target, key, value);
+  }
+  return value;
+}
+__name(findObservable, "findObservable");
+function patchIterator(target, key, iterator, isEntries) {
+  const originalNext = iterator.next;
+  iterator.next = () => {
+    let { done, value } = originalNext.call(iterator);
+    if (!done) {
+      if (isEntries) {
+        value[1] = findObservable(target, key, value[1]);
+      } else {
+        value = findObservable(target, key, value);
+      }
+    }
+    return { done, value };
+  };
+  return iterator;
+}
+__name(patchIterator, "patchIterator");
+const instrumentations = {
+  has(key) {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, key, type: "has" });
+    return proto.has.apply(target, arguments);
+  },
+  get(key) {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, key, type: "get" });
+    return findObservable(target, key, proto.get.apply(target, arguments));
+  },
+  add(key) {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    const hadKey = proto.has.call(target, key);
+    const result = proto.add.apply(target, arguments);
+    if (!hadKey) {
+      (0, import_reaction.runReactionsFromTargetKey)({ target, key, value: key, type: "add" });
+    }
+    return result;
+  },
+  set(key, value) {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    const hadKey = proto.has.call(target, key);
+    const oldValue = proto.get.call(target, key);
+    const result = proto.set.apply(target, arguments);
+    if (!hadKey) {
+      (0, import_reaction.runReactionsFromTargetKey)({ target, key, value, type: "add" });
+    } else if (value !== oldValue) {
+      (0, import_reaction.runReactionsFromTargetKey)({ target, key, value, oldValue, type: "set" });
+    }
+    return result;
+  },
+  delete(key) {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    const hadKey = proto.has.call(target, key);
+    const oldValue = proto.get ? proto.get.call(target, key) : void 0;
+    const result = proto.delete.apply(target, arguments);
+    if (hadKey) {
+      (0, import_reaction.runReactionsFromTargetKey)({ target, key, oldValue, type: "delete" });
+    }
+    return result;
+  },
+  clear() {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    const hadItems = target.size !== 0;
+    const oldTarget = target instanceof Map ? new Map(target) : new Set(target);
+    const result = proto.clear.apply(target, arguments);
+    if (hadItems) {
+      (0, import_reaction.runReactionsFromTargetKey)({ target, oldTarget, type: "clear" });
+    }
+    return result;
+  },
+  forEach(cb, ...args) {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    const wrappedCb = /* @__PURE__ */ __name((value, key, ...args2) => cb(findObservable(target, key, value), key, ...args2), "wrappedCb");
+    return proto.forEach.call(target, wrappedCb, ...args);
+  },
+  keys() {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    return proto.keys.apply(target, arguments);
+  },
+  values() {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    const iterator = proto.values.apply(target, arguments);
+    return patchIterator(target, "", iterator, false);
+  },
+  entries() {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    const iterator = proto.entries.apply(target, arguments);
+    return patchIterator(target, "", iterator, true);
+  },
+  [Symbol.iterator]() {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    const iterator = proto[Symbol.iterator].apply(target, arguments);
+    return patchIterator(target, "", iterator, target instanceof Map);
+  },
+  get size() {
+    const target = import_environment.ProxyRaw.get(this);
+    const proto = Reflect.getPrototypeOf(this);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    return Reflect.get(proto, "size", target);
+  }
+};
+const collectionHandlers = {
+  get(target, key, receiver) {
+    target = hasOwnProperty.call(instrumentations, key) ? instrumentations : target;
+    return Reflect.get(target, key, receiver);
+  }
+};
+const baseHandlers = {
+  get(target, key, receiver) {
+    if (!key) return;
+    const result = target[key];
+    if (typeof key === "symbol" && wellKnownSymbols.has(key)) {
+      return result;
+    }
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, key, receiver, type: "get" });
+    const observableResult = import_environment.RawProxy.get(result);
+    if (observableResult) {
+      return observableResult;
+    }
+    if (!(0, import_externals.isObservable)(result) && (0, import_externals.isSupportObservable)(result)) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+      if (!descriptor || !(descriptor.writable === false && descriptor.configurable === false)) {
+        return (0, import_internals.createObservable)(target, key, result);
+      }
+    }
+    return result;
+  },
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, key, type: "has" });
+    return result;
+  },
+  ownKeys(target) {
+    const keys = Reflect.ownKeys(target);
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({ target, type: "iterate" });
+    return keys;
+  },
+  set(target, key, value, receiver) {
+    if (key === "__proto__") {
+      target[key] = value;
+      return true;
+    }
+    const hadKey = hasOwnProperty.call(target, key);
+    const newValue = (0, import_internals.createObservable)(target, key, value);
+    const oldValue = target[key];
+    target[key] = newValue;
+    if (!hadKey) {
+      (0, import_reaction.runReactionsFromTargetKey)({
+        target,
+        key,
+        value: newValue,
+        oldValue,
+        receiver,
+        type: "add"
+      });
+    } else if (value !== oldValue) {
+      (0, import_reaction.runReactionsFromTargetKey)({
+        target,
+        key,
+        value: newValue,
+        oldValue,
+        receiver,
+        type: "set"
+      });
+    }
+    return true;
+  },
+  deleteProperty(target, key) {
+    const oldValue = target[key];
+    delete target[key];
+    (0, import_reaction.runReactionsFromTargetKey)({
+      target,
+      key,
+      oldValue,
+      type: "delete"
+    });
+    return true;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baseHandlers,
+  collectionHandlers
+});

package/lib/reactive/index.d.ts

@@ -0,0 +1,10 @@
+export * from './batch';
+export * from './action';
+export * from './untracked';
+export * from './observable';
+export * from './model';
+export * from './autorun';
+export * from './tracker';
+export * from './observe';
+export * from './externals';
+export * from './types';

package/lib/reactive/index.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reactive_exports = {};
+module.exports = __toCommonJS(reactive_exports);
+__reExport(reactive_exports, require("./batch"), module.exports);
+__reExport(reactive_exports, require("./action"), module.exports);
+__reExport(reactive_exports, require("./untracked"), module.exports);
+__reExport(reactive_exports, require("./observable"), module.exports);
+__reExport(reactive_exports, require("./model"), module.exports);
+__reExport(reactive_exports, require("./autorun"), module.exports);
+__reExport(reactive_exports, require("./tracker"), module.exports);
+__reExport(reactive_exports, require("./observe"), module.exports);
+__reExport(reactive_exports, require("./externals"), module.exports);
+__reExport(reactive_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./batch"),
+  ...require("./action"),
+  ...require("./untracked"),
+  ...require("./observable"),
+  ...require("./model"),
+  ...require("./autorun"),
+  ...require("./tracker"),
+  ...require("./observe"),
+  ...require("./externals"),
+  ...require("./types")
+});

package/lib/reactive/internals.d.ts

@@ -0,0 +1,17 @@
+import { MakeObModelSymbol } from './environment';
+import { BoundaryFunction, IVisitor, PropertyKey } from './types';
+export declare const createObservable: (target: any, key?: PropertyKey, value?: any, shallow?: boolean) => any;
+export declare const createAnnotation: <T extends (visitor: IVisitor) => any>(maker: T) => {
+    (target: any): ReturnType<T>;
+    [MakeObModelSymbol]: T;
+};
+export declare const getObservableMaker: (target: any) => any;
+export declare const createBoundaryFunction: (start: (...args: any) => void, end: (...args: any) => void) => {
+    <F extends (...args: any) => any>(fn?: F): ReturnType<F>;
+    bound: <F extends (...args: any[]) => any>(callback?: F, context?: any) => F;
+};
+export declare const createBindFunction: <Boundary extends BoundaryFunction>(boundary: Boundary) => <F extends (...args: any[]) => any>(callback?: F, context?: any) => F;
+export declare const createBoundaryAnnotation: (start: (...args: any) => void, end: (...args: any) => void) => {
+    <F extends (...args: any) => any>(fn?: F): ReturnType<F>;
+    bound: <F extends (...args: any[]) => any>(callback?: F, context?: any) => F;
+};

package/lib/reactive/internals.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internals_exports = {};
+__export(internals_exports, {
+  createAnnotation: () => createAnnotation,
+  createBindFunction: () => createBindFunction,
+  createBoundaryAnnotation: () => createBoundaryAnnotation,
+  createBoundaryFunction: () => createBoundaryFunction,
+  createObservable: () => createObservable,
+  getObservableMaker: () => getObservableMaker
+});
+module.exports = __toCommonJS(internals_exports);
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_externals = require("./externals");
+var import_handlers = require("./handlers");
+var import_tree = require("./tree");
+const createNormalProxy = /* @__PURE__ */ __name((target, shallow) => {
+  const proxy = new Proxy(target, import_handlers.baseHandlers);
+  import_environment.ProxyRaw.set(proxy, target);
+  if (shallow) {
+    import_environment.RawShallowProxy.set(target, proxy);
+  } else {
+    import_environment.RawProxy.set(target, proxy);
+  }
+  return proxy;
+}, "createNormalProxy");
+const createCollectionProxy = /* @__PURE__ */ __name((target, shallow) => {
+  const proxy = new Proxy(target, import_handlers.collectionHandlers);
+  import_environment.ProxyRaw.set(proxy, target);
+  if (shallow) {
+    import_environment.RawShallowProxy.set(target, proxy);
+  } else {
+    import_environment.RawProxy.set(target, proxy);
+  }
+  return proxy;
+}, "createCollectionProxy");
+const createShallowProxy = /* @__PURE__ */ __name((target) => {
+  if ((0, import_checkers.isNormalType)(target)) return createNormalProxy(target, true);
+  if ((0, import_checkers.isCollectionType)(target)) return createCollectionProxy(target, true);
+  return target;
+}, "createShallowProxy");
+const createObservable = /* @__PURE__ */ __name((target, key, value, shallow) => {
+  if (typeof value !== "object") return value;
+  const raw = import_environment.ProxyRaw.get(value);
+  if (!!raw) {
+    const node = (0, import_tree.getDataNode)(raw);
+    if (!node.target) node.target = target;
+    node.key = key;
+    return value;
+  }
+  if (!(0, import_externals.isSupportObservable)(value)) return value;
+  if (target) {
+    const parentRaw = import_environment.ProxyRaw.get(target) || target;
+    const isShallowParent = import_environment.RawShallowProxy.get(parentRaw);
+    if (isShallowParent) return value;
+  }
+  (0, import_tree.buildDataTree)(target, key, value);
+  if (shallow) return createShallowProxy(value);
+  if ((0, import_checkers.isNormalType)(value)) return createNormalProxy(value);
+  if ((0, import_checkers.isCollectionType)(value)) return createCollectionProxy(value);
+  return value;
+}, "createObservable");
+const createAnnotation = /* @__PURE__ */ __name((maker) => {
+  const annotation = /* @__PURE__ */ __name((target) => {
+    return maker({ value: target });
+  }, "annotation");
+  if ((0, import_checkers.isFn)(maker)) {
+    annotation[import_environment.MakeObModelSymbol] = maker;
+  }
+  return annotation;
+}, "createAnnotation");
+const getObservableMaker = /* @__PURE__ */ __name((target) => {
+  if (target[import_environment.MakeObModelSymbol]) {
+    if (!target[import_environment.MakeObModelSymbol][import_environment.MakeObModelSymbol]) {
+      return target[import_environment.MakeObModelSymbol];
+    }
+    return getObservableMaker(target[import_environment.MakeObModelSymbol]);
+  }
+}, "getObservableMaker");
+const createBoundaryFunction = /* @__PURE__ */ __name((start, end) => {
+  function boundary(fn) {
+    let results;
+    try {
+      start();
+      if ((0, import_checkers.isFn)(fn)) {
+        results = fn();
+      }
+    } finally {
+      end();
+    }
+    return results;
+  }
+  __name(boundary, "boundary");
+  boundary.bound = createBindFunction(boundary);
+  return boundary;
+}, "createBoundaryFunction");
+const createBindFunction = /* @__PURE__ */ __name((boundary) => {
+  function bind(callback, context) {
+    return (...args) => boundary(() => callback.apply(context, args));
+  }
+  __name(bind, "bind");
+  return bind;
+}, "createBindFunction");
+const createBoundaryAnnotation = /* @__PURE__ */ __name((start, end) => {
+  const boundary = createBoundaryFunction(start, end);
+  const annotation = createAnnotation(({ target, key }) => {
+    target[key] = boundary.bound(target[key], target);
+    return target;
+  });
+  boundary[import_environment.MakeObModelSymbol] = annotation;
+  boundary.bound[import_environment.MakeObModelSymbol] = annotation;
+  return boundary;
+}, "createBoundaryAnnotation");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAnnotation,
+  createBindFunction,
+  createBoundaryAnnotation,
+  createBoundaryFunction,
+  createObservable,
+  getObservableMaker
+});

package/lib/reactive/model.d.ts

@@ -0,0 +1,3 @@
+import { Annotations } from './types';
+export declare function define<Target extends object = any>(target: Target, annotations?: Annotations<Target>): Target;
+export declare function model<Target extends object = any>(target: Target): Target;

package/lib/reactive/model.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_exports = {};
+__export(model_exports, {
+  define: () => define,
+  model: () => model
+});
+module.exports = __toCommonJS(model_exports);
+var import_action = require("./action");
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_externals = require("./externals");
+var import_internals = require("./internals");
+var import_observable = require("./observable");
+var import_tree = require("./tree");
+function define(target, annotations) {
+  if ((0, import_externals.isObservable)(target)) return target;
+  if (!(0, import_externals.isSupportObservable)(target)) return target;
+  target[import_environment.ObModelSymbol] = target;
+  (0, import_tree.buildDataTree)(void 0, void 0, target);
+  for (const key in annotations) {
+    const annotation = annotations[key];
+    if ((0, import_externals.isAnnotation)(annotation)) {
+      (0, import_internals.getObservableMaker)(annotation)({
+        target,
+        key
+      });
+    }
+  }
+  return target;
+}
+__name(define, "define");
+function model(target) {
+  const annotations = Object.keys(target || {}).reduce((buf, key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor && descriptor.get) {
+      buf[key] = import_observable.observable.computed;
+    } else if ((0, import_checkers.isFn)(target[key])) {
+      buf[key] = import_action.action;
+    } else {
+      buf[key] = import_observable.observable;
+    }
+    return buf;
+  }, {});
+  return define(target, annotations);
+}
+__name(model, "model");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  define,
+  model
+});

package/lib/reactive/observable.d.ts

@@ -0,0 +1,9 @@
+import * as annotations from './annotations';
+export declare function observable<T extends object>(target: T): T;
+export declare namespace observable {
+    var box: annotations.IBox;
+    var ref: annotations.IRef;
+    var deep: annotations.IObservable;
+    var shallow: annotations.IObservable;
+    var computed: annotations.IComputed;
+}

package/lib/reactive/observable.js

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var observable_exports = {};
+__export(observable_exports, {
+  observable: () => observable
+});
+module.exports = __toCommonJS(observable_exports);
+var annotations = __toESM(require("./annotations"));
+var import_environment = require("./environment");
+var import_internals = require("./internals");
+function observable(target) {
+  return (0, import_internals.createObservable)(null, null, target);
+}
+__name(observable, "observable");
+observable.box = annotations.box;
+observable.ref = annotations.ref;
+observable.deep = annotations.observable;
+observable.shallow = annotations.shallow;
+observable.computed = annotations.computed;
+observable[import_environment.MakeObModelSymbol] = annotations.observable;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  observable
+});

package/lib/reactive/observe.d.ts

@@ -0,0 +1,2 @@
+import { DataChange } from './tree';
+export declare const observe: (target: object, observer?: (change: DataChange) => void, deep?: boolean) => () => void;

package/lib/reactive/observe.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var observe_exports = {};
+__export(observe_exports, {
+  observe: () => observe
+});
+module.exports = __toCommonJS(observe_exports);
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_externals = require("./externals");
+var import_tree = require("./tree");
+const observe = /* @__PURE__ */ __name((target, observer, deep = true) => {
+  const addListener = /* @__PURE__ */ __name((target2) => {
+    const raw = (0, import_externals.raw)(target2);
+    const node = (0, import_tree.getDataNode)(raw);
+    const listener = /* @__PURE__ */ __name((operation) => {
+      const targetRaw = (0, import_externals.raw)(operation.target);
+      const targetNode = (0, import_tree.getDataNode)(targetRaw);
+      if (deep) {
+        if (node.contains(targetNode)) {
+          observer(new import_tree.DataChange(operation, targetNode));
+          return;
+        }
+      }
+      if (node === targetNode || node.targetRaw === targetRaw && node.key === operation.key) {
+        observer(new import_tree.DataChange(operation, targetNode));
+      }
+    }, "listener");
+    if (node && (0, import_checkers.isFn)(observer)) {
+      import_environment.ObserverListeners.add(listener);
+    }
+    return () => {
+      import_environment.ObserverListeners.delete(listener);
+    };
+  }, "addListener");
+  if (target && typeof target !== "object") throw Error(`Can not observe ${typeof target} type.`);
+  return addListener(target);
+}, "observe");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  observe
+});

package/lib/reactive/reaction.d.ts

@@ -0,0 +1,21 @@
+import { IOperation, Reaction } from './types';
+export declare const bindTargetKeyWithCurrentReaction: (operation: IOperation) => void;
+export declare const bindComputedReactions: (reaction: Reaction) => void;
+export declare const runReactionsFromTargetKey: (operation: IOperation) => void;
+export declare const hasRunningReaction: () => boolean;
+export declare const releaseBindingReactions: (reaction: Reaction) => void;
+export declare const suspendComputedReactions: (current: Reaction) => void;
+export declare const disposeBindingReactions: (reaction: Reaction) => void;
+export declare const batchStart: () => void;
+export declare const batchEnd: () => void;
+export declare const batchScopeStart: () => void;
+export declare const batchScopeEnd: () => void;
+export declare const untrackStart: () => void;
+export declare const untrackEnd: () => void;
+export declare const isBatching: () => boolean;
+export declare const isScopeBatching: () => boolean;
+export declare const isUntracking: () => boolean;
+export declare const executePendingReactions: () => void;
+export declare const executeBatchEndpoints: () => void;
+export declare const hasDepsChange: (newDeps: any[], oldDeps: any[]) => boolean;
+export declare const disposeEffects: (reaction: Reaction) => void;