@tachybase/schema 0.23.40 → 0.23.47

package/lib/reactive/reaction.js

@@ -0,0 +1,278 @@
+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 reaction_exports = {};
+__export(reaction_exports, {
+  batchEnd: () => batchEnd,
+  batchScopeEnd: () => batchScopeEnd,
+  batchScopeStart: () => batchScopeStart,
+  batchStart: () => batchStart,
+  bindComputedReactions: () => bindComputedReactions,
+  bindTargetKeyWithCurrentReaction: () => bindTargetKeyWithCurrentReaction,
+  disposeBindingReactions: () => disposeBindingReactions,
+  disposeEffects: () => disposeEffects,
+  executeBatchEndpoints: () => executeBatchEndpoints,
+  executePendingReactions: () => executePendingReactions,
+  hasDepsChange: () => hasDepsChange,
+  hasRunningReaction: () => hasRunningReaction,
+  isBatching: () => isBatching,
+  isScopeBatching: () => isScopeBatching,
+  isUntracking: () => isUntracking,
+  releaseBindingReactions: () => releaseBindingReactions,
+  runReactionsFromTargetKey: () => runReactionsFromTargetKey,
+  suspendComputedReactions: () => suspendComputedReactions,
+  untrackEnd: () => untrackEnd,
+  untrackStart: () => untrackStart
+});
+module.exports = __toCommonJS(reaction_exports);
+var import_array = require("./array");
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+const ITERATION_KEY = Symbol("iteration key");
+const addRawReactionsMap = /* @__PURE__ */ __name((target, key, reaction) => {
+  const reactionsMap = import_environment.RawReactionsMap.get(target);
+  if (reactionsMap) {
+    const reactions = reactionsMap.get(key);
+    if (reactions) {
+      reactions.add(reaction);
+    } else {
+      reactionsMap.set(key, new import_array.ArraySet([reaction]));
+    }
+    return reactionsMap;
+  } else {
+    const reactionsMap2 = /* @__PURE__ */ new Map([[key, new import_array.ArraySet([reaction])]]);
+    import_environment.RawReactionsMap.set(target, reactionsMap2);
+    return reactionsMap2;
+  }
+}, "addRawReactionsMap");
+const addReactionsMapToReaction = /* @__PURE__ */ __name((reaction, reactionsMap) => {
+  const bindSet = reaction._reactionsSet;
+  if (bindSet) {
+    bindSet.add(reactionsMap);
+  } else {
+    reaction._reactionsSet = new import_array.ArraySet([reactionsMap]);
+  }
+  return bindSet;
+}, "addReactionsMapToReaction");
+const getReactionsFromTargetKey = /* @__PURE__ */ __name((target, key) => {
+  const reactionsMap = import_environment.RawReactionsMap.get(target);
+  const reactions = [];
+  if (reactionsMap) {
+    const map = reactionsMap.get(key);
+    if (map) {
+      map.forEach((reaction) => {
+        if (reactions.indexOf(reaction) === -1) {
+          reactions.push(reaction);
+        }
+      });
+    }
+  }
+  return reactions;
+}, "getReactionsFromTargetKey");
+const runReactions = /* @__PURE__ */ __name((target, key) => {
+  const reactions = getReactionsFromTargetKey(target, key);
+  const prevUntrackCount = import_environment.UntrackCount.value;
+  import_environment.UntrackCount.value = 0;
+  for (let i = 0, len = reactions.length; i < len; i++) {
+    const reaction = reactions[i];
+    if (reaction._isComputed) {
+      reaction._scheduler(reaction);
+    } else if (isScopeBatching()) {
+      import_environment.PendingScopeReactions.add(reaction);
+    } else if (isBatching()) {
+      import_environment.PendingReactions.add(reaction);
+    } else {
+      if ((0, import_checkers.isFn)(reaction._scheduler)) {
+        reaction._scheduler(reaction);
+      } else {
+        reaction();
+      }
+    }
+  }
+  import_environment.UntrackCount.value = prevUntrackCount;
+}, "runReactions");
+const notifyObservers = /* @__PURE__ */ __name((operation) => {
+  import_environment.ObserverListeners.forEach((fn) => fn(operation));
+}, "notifyObservers");
+const bindTargetKeyWithCurrentReaction = /* @__PURE__ */ __name((operation) => {
+  let { key, type, target } = operation;
+  if (type === "iterate") {
+    key = ITERATION_KEY;
+  }
+  const reactionLen = import_environment.ReactionStack.length;
+  if (reactionLen === 0) return;
+  const current = import_environment.ReactionStack[reactionLen - 1];
+  if (isUntracking()) return;
+  if (current) {
+    import_environment.DependencyCollected.value = true;
+    addReactionsMapToReaction(current, addRawReactionsMap(target, key, current));
+  }
+}, "bindTargetKeyWithCurrentReaction");
+const bindComputedReactions = /* @__PURE__ */ __name((reaction) => {
+  if ((0, import_checkers.isFn)(reaction)) {
+    const current = import_environment.ReactionStack[import_environment.ReactionStack.length - 1];
+    if (current) {
+      const computes = current._computesSet;
+      if (computes) {
+        computes.add(reaction);
+      } else {
+        current._computesSet = new import_array.ArraySet([reaction]);
+      }
+    }
+  }
+}, "bindComputedReactions");
+const runReactionsFromTargetKey = /* @__PURE__ */ __name((operation) => {
+  let { key, type, target, oldTarget } = operation;
+  batchStart();
+  notifyObservers(operation);
+  if (type === "clear") {
+    oldTarget.forEach((_, key2) => {
+      runReactions(target, key2);
+    });
+  } else {
+    runReactions(target, key);
+  }
+  if (type === "add" || type === "delete" || type === "clear") {
+    const newKey = Array.isArray(target) ? "length" : ITERATION_KEY;
+    runReactions(target, newKey);
+  }
+  batchEnd();
+}, "runReactionsFromTargetKey");
+const hasRunningReaction = /* @__PURE__ */ __name(() => {
+  return import_environment.ReactionStack.length > 0;
+}, "hasRunningReaction");
+const releaseBindingReactions = /* @__PURE__ */ __name((reaction) => {
+  var _a;
+  (_a = reaction._reactionsSet) == null ? void 0 : _a.forEach((reactionsMap) => {
+    reactionsMap.forEach((reactions) => {
+      reactions.delete(reaction);
+    });
+  });
+  import_environment.PendingReactions.delete(reaction);
+  import_environment.PendingScopeReactions.delete(reaction);
+  delete reaction._reactionsSet;
+}, "releaseBindingReactions");
+const suspendComputedReactions = /* @__PURE__ */ __name((current) => {
+  var _a;
+  (_a = current._computesSet) == null ? void 0 : _a.forEach((reaction) => {
+    const reactions = getReactionsFromTargetKey(reaction._context, reaction._property);
+    if (reactions.length === 0) {
+      disposeBindingReactions(reaction);
+      reaction._dirty = true;
+    }
+  });
+}, "suspendComputedReactions");
+const disposeBindingReactions = /* @__PURE__ */ __name((reaction) => {
+  reaction._disposed = true;
+  releaseBindingReactions(reaction);
+  suspendComputedReactions(reaction);
+}, "disposeBindingReactions");
+const batchStart = /* @__PURE__ */ __name(() => {
+  import_environment.BatchCount.value++;
+}, "batchStart");
+const batchEnd = /* @__PURE__ */ __name(() => {
+  import_environment.BatchCount.value--;
+  if (import_environment.BatchCount.value === 0) {
+    const prevUntrackCount = import_environment.UntrackCount.value;
+    import_environment.UntrackCount.value = 0;
+    executePendingReactions();
+    executeBatchEndpoints();
+    import_environment.UntrackCount.value = prevUntrackCount;
+  }
+}, "batchEnd");
+const batchScopeStart = /* @__PURE__ */ __name(() => {
+  import_environment.BatchScope.value = true;
+}, "batchScopeStart");
+const batchScopeEnd = /* @__PURE__ */ __name(() => {
+  const prevUntrackCount = import_environment.UntrackCount.value;
+  import_environment.BatchScope.value = false;
+  import_environment.UntrackCount.value = 0;
+  import_environment.PendingScopeReactions.batchDelete((reaction) => {
+    if ((0, import_checkers.isFn)(reaction._scheduler)) {
+      reaction._scheduler(reaction);
+    } else {
+      reaction();
+    }
+  });
+  import_environment.UntrackCount.value = prevUntrackCount;
+}, "batchScopeEnd");
+const untrackStart = /* @__PURE__ */ __name(() => {
+  import_environment.UntrackCount.value++;
+}, "untrackStart");
+const untrackEnd = /* @__PURE__ */ __name(() => {
+  import_environment.UntrackCount.value--;
+}, "untrackEnd");
+const isBatching = /* @__PURE__ */ __name(() => import_environment.BatchCount.value > 0, "isBatching");
+const isScopeBatching = /* @__PURE__ */ __name(() => import_environment.BatchScope.value, "isScopeBatching");
+const isUntracking = /* @__PURE__ */ __name(() => import_environment.UntrackCount.value > 0, "isUntracking");
+const executePendingReactions = /* @__PURE__ */ __name(() => {
+  import_environment.PendingReactions.batchDelete((reaction) => {
+    if ((0, import_checkers.isFn)(reaction._scheduler)) {
+      reaction._scheduler(reaction);
+    } else {
+      reaction();
+    }
+  });
+}, "executePendingReactions");
+const executeBatchEndpoints = /* @__PURE__ */ __name(() => {
+  import_environment.BatchEndpoints.batchDelete((callback) => {
+    callback();
+  });
+}, "executeBatchEndpoints");
+const hasDepsChange = /* @__PURE__ */ __name((newDeps, oldDeps) => {
+  if (newDeps === oldDeps) return false;
+  if (newDeps.length !== oldDeps.length) return true;
+  if (newDeps.some((value, index) => value !== oldDeps[index])) return true;
+  return false;
+}, "hasDepsChange");
+const disposeEffects = /* @__PURE__ */ __name((reaction) => {
+  if (reaction._effects) {
+    try {
+      batchStart();
+      reaction._effects.queue.forEach((item) => {
+        if (!item || !item.dispose) return;
+        item.dispose();
+      });
+    } finally {
+      batchEnd();
+    }
+  }
+}, "disposeEffects");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  batchEnd,
+  batchScopeEnd,
+  batchScopeStart,
+  batchStart,
+  bindComputedReactions,
+  bindTargetKeyWithCurrentReaction,
+  disposeBindingReactions,
+  disposeEffects,
+  executeBatchEndpoints,
+  executePendingReactions,
+  hasDepsChange,
+  hasRunningReaction,
+  isBatching,
+  isScopeBatching,
+  isUntracking,
+  releaseBindingReactions,
+  runReactionsFromTargetKey,
+  suspendComputedReactions,
+  untrackEnd,
+  untrackStart
+});

package/lib/reactive/tracker.d.ts

@@ -0,0 +1,7 @@
+import { Reaction } from './types';
+export declare class Tracker {
+    private results;
+    constructor(scheduler?: (reaction: Reaction) => void, name?: string);
+    track: Reaction;
+    dispose: () => void;
+}

package/lib/reactive/tracker.js

@@ -0,0 +1,63 @@
+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 tracker_exports = {};
+__export(tracker_exports, {
+  Tracker: () => Tracker
+});
+module.exports = __toCommonJS(tracker_exports);
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_reaction = require("./reaction");
+const _Tracker = class _Tracker {
+  constructor(scheduler, name = "TrackerReaction") {
+    this.track = /* @__PURE__ */ __name((tracker) => {
+      if (!(0, import_checkers.isFn)(tracker)) return this.results;
+      if (this.track._boundary > 0) return;
+      if (import_environment.ReactionStack.indexOf(this.track) === -1) {
+        (0, import_reaction.releaseBindingReactions)(this.track);
+        try {
+          (0, import_reaction.batchStart)();
+          import_environment.ReactionStack.push(this.track);
+          this.results = tracker();
+        } finally {
+          import_environment.ReactionStack.pop();
+          this.track._boundary++;
+          (0, import_reaction.batchEnd)();
+          this.track._boundary = 0;
+        }
+      }
+      return this.results;
+    }, "track");
+    this.dispose = /* @__PURE__ */ __name(() => {
+      (0, import_reaction.disposeBindingReactions)(this.track);
+    }, "dispose");
+    this.track._scheduler = (callback) => {
+      if (this.track._boundary === 0) this.dispose();
+      if ((0, import_checkers.isFn)(callback)) scheduler(callback);
+    };
+    this.track._name = name;
+    this.track._boundary = 0;
+  }
+};
+__name(_Tracker, "Tracker");
+let Tracker = _Tracker;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tracker
+});

package/lib/reactive/tree.d.ts

@@ -0,0 +1,25 @@
+import { IOperation, PropertyKey } from './types';
+export declare class DataChange {
+    node: DataNode;
+    key: PropertyKey;
+    object: object;
+    type: string;
+    value: any;
+    oldValue: any;
+    constructor(operation: IOperation, node: DataNode);
+    get path(): any;
+}
+export declare class DataNode {
+    target: any;
+    key: PropertyKey;
+    value: any;
+    constructor(target: any, key: PropertyKey, value: any);
+    get path(): any;
+    get targetRaw(): any;
+    get parent(): any;
+    isEqual(node: DataNode): boolean;
+    contains(node: DataNode): boolean;
+}
+export declare const getDataNode: (raw: any) => any;
+export declare const setDataNode: (raw: any, node: DataNode) => void;
+export declare const buildDataTree: (target: any, key: PropertyKey, value: any) => any;

package/lib/reactive/tree.js

@@ -0,0 +1,106 @@
+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 tree_exports = {};
+__export(tree_exports, {
+  DataChange: () => DataChange,
+  DataNode: () => DataNode,
+  buildDataTree: () => buildDataTree,
+  getDataNode: () => getDataNode,
+  setDataNode: () => setDataNode
+});
+module.exports = __toCommonJS(tree_exports);
+var import_environment = require("./environment");
+var import_externals = require("./externals");
+const _DataChange = class _DataChange {
+  constructor(operation, node) {
+    this.node = node;
+    this.key = operation.key;
+    this.type = operation.type;
+    this.object = operation.target;
+    this.value = operation.value;
+    this.oldValue = operation.oldValue;
+  }
+  get path() {
+    return this.node.path.concat(this.key);
+  }
+};
+__name(_DataChange, "DataChange");
+let DataChange = _DataChange;
+const _DataNode = class _DataNode {
+  constructor(target, key, value) {
+    this.target = target;
+    this.key = key;
+    this.value = value;
+  }
+  get path() {
+    if (!this.parent) return this.key ? [this.key] : [];
+    return this.parent.path.concat(this.key);
+  }
+  get targetRaw() {
+    return (0, import_externals.raw)(this.target);
+  }
+  get parent() {
+    if (!this.target) return;
+    return getDataNode(this.targetRaw);
+  }
+  isEqual(node) {
+    if (this.key) {
+      return node.targetRaw === this.targetRaw && node.key === this.key;
+    }
+    return node.value === this.value;
+  }
+  contains(node) {
+    if (node === this) return true;
+    let parent = node.parent;
+    while (!!parent) {
+      if (this.isEqual(parent)) return true;
+      parent = parent.parent;
+    }
+    return false;
+  }
+};
+__name(_DataNode, "DataNode");
+let DataNode = _DataNode;
+const getDataNode = /* @__PURE__ */ __name((raw) => {
+  if (raw == null ? void 0 : raw[import_environment.ObModelNodeSymbol]) {
+    return raw[import_environment.ObModelNodeSymbol];
+  }
+  return import_environment.RawNode.get(raw);
+}, "getDataNode");
+const setDataNode = /* @__PURE__ */ __name((raw, node) => {
+  if (raw == null ? void 0 : raw[import_environment.ObModelSymbol]) {
+    raw[import_environment.ObModelNodeSymbol] = node;
+    return;
+  }
+  import_environment.RawNode.set(raw, node);
+}, "setDataNode");
+const buildDataTree = /* @__PURE__ */ __name((target, key, value) => {
+  const raw = (0, import_externals.raw)(value);
+  const currentNode = getDataNode(raw);
+  if (currentNode) return currentNode;
+  setDataNode(raw, new DataNode(target, key, value));
+}, "buildDataTree");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataChange,
+  DataNode,
+  buildDataTree,
+  getDataNode,
+  setDataNode
+});

package/lib/reactive/types.d.ts

@@ -0,0 +1,79 @@
+import { ArraySet } from './array';
+export * from './tree';
+export type PropertyKey = string | number | symbol;
+export type OperationType = 'add' | 'delete' | 'clear' | 'set' | 'get' | 'iterate' | 'has';
+export interface IOperation {
+    target?: any;
+    oldTarget?: any;
+    key?: PropertyKey;
+    value?: any;
+    oldValue?: any;
+    type?: OperationType;
+    receiver?: any;
+}
+export interface IChange {
+    key?: PropertyKey;
+    path?: ObservablePath;
+    value?: any;
+    oldValue?: any;
+    type?: OperationType;
+}
+export interface IEffectQueueItem {
+    dispose?: void | Dispose;
+    deps?: any[];
+}
+export interface IMemoQueueItem {
+    value?: any;
+    deps?: any[];
+}
+export interface IVisitor<Value = any, Target = any> {
+    target?: Target;
+    key?: PropertyKey;
+    value?: Value;
+}
+export type Annotation = (...args: any[]) => any;
+export type Annotations<T = any> = {
+    [key in keyof T]?: Annotation;
+};
+export type ObservableListener = (operation: IOperation) => void;
+export type ObservablePath = Array<string | number>;
+export type Dispose = () => void;
+export type Effect = () => void | Dispose;
+export type Reaction = ((...args: any[]) => any) & {
+    _boundary?: number;
+    _name?: string;
+    _isComputed?: boolean;
+    _dirty?: boolean;
+    _context?: any;
+    _disposed?: boolean;
+    _property?: PropertyKey;
+    _computesSet?: ArraySet<Reaction>;
+    _reactionsSet?: ArraySet<ReactionsMap>;
+    _scheduler?: (reaction: Reaction) => void;
+    _memos?: {
+        queue: IMemoQueueItem[];
+        cursor: number;
+    };
+    _effects?: {
+        queue: IEffectQueueItem[];
+        cursor: number;
+    };
+};
+export type ReactionsMap = Map<PropertyKey, ArraySet<Reaction>>;
+export interface IReactionOptions<T> {
+    name?: string;
+    equals?: (oldValue: T, newValue: T) => boolean;
+    fireImmediately?: boolean;
+}
+export type BindFunction<F = (...args: any[]) => any> = (callback?: F, context?: any) => F;
+export type BoundaryFunction = <F extends (...args: any) => any>(fn?: F) => ReturnType<F>;
+export interface IBoundable {
+    bound?: <T extends (...args: any[]) => any>(callback: T, context?: any) => T;
+}
+export interface IAction extends IBoundable {
+    <T>(callback?: () => T): T;
+    scope?: (<T>(callback?: () => T) => T) & IBoundable;
+}
+export interface IBatch extends IAction {
+    endpoint?: (callback?: () => void) => void;
+}

package/lib/reactive/types.js

@@ -0,0 +1,21 @@
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./tree"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./tree")
+});

package/lib/reactive/untracked.d.ts

@@ -0,0 +1,4 @@
+export declare const untracked: {
+    <F extends (...args: any) => any>(fn?: F): ReturnType<F>;
+    bound: <F extends (...args: any[]) => any>(callback?: F, context?: any) => F;
+};

package/lib/reactive/untracked.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 untracked_exports = {};
+__export(untracked_exports, {
+  untracked: () => untracked
+});
+module.exports = __toCommonJS(untracked_exports);
+var import_internals = require("./internals");
+var import_reaction = require("./reaction");
+const untracked = (0, import_internals.createBoundaryFunction)(import_reaction.untrackStart, import_reaction.untrackEnd);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  untracked
+});

package/lib/reactive-react/hooks/index.d.ts

@@ -0,0 +1,9 @@
+import { useForceUpdate } from './useForceUpdate';
+export declare const unstable_useForceUpdate: typeof useForceUpdate;
+export declare const unstable_useCompatEffect: (effect: import("react").EffectCallback, deps?: import("react").DependencyList) => void;
+export declare const unstable_useCompatFactory: <T extends {
+    dispose: () => void;
+}>(factory: () => T) => T;
+export declare const unstable_useDidUpdate: (callback?: () => void) => void;
+export declare const unstable_useLayoutEffect: typeof import("react").useEffect;
+export declare const unstable_useObserver: <T extends () => any>(view: T, options?: import("..").IObserverOptions) => ReturnType<T>;

package/lib/reactive-react/hooks/index.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 hooks_exports = {};
+__export(hooks_exports, {
+  unstable_useCompatEffect: () => unstable_useCompatEffect,
+  unstable_useCompatFactory: () => unstable_useCompatFactory,
+  unstable_useDidUpdate: () => unstable_useDidUpdate,
+  unstable_useForceUpdate: () => unstable_useForceUpdate,
+  unstable_useLayoutEffect: () => unstable_useLayoutEffect,
+  unstable_useObserver: () => unstable_useObserver
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_useCompatEffect = require("./useCompatEffect");
+var import_useCompatFactory = require("./useCompatFactory");
+var import_useDidUpdate = require("./useDidUpdate");
+var import_useForceUpdate = require("./useForceUpdate");
+var import_useLayoutEffect = require("./useLayoutEffect");
+var import_useObserver = require("./useObserver");
+const unstable_useForceUpdate = import_useForceUpdate.useForceUpdate;
+const unstable_useCompatEffect = import_useCompatEffect.useCompatEffect;
+const unstable_useCompatFactory = import_useCompatFactory.useCompatFactory;
+const unstable_useDidUpdate = import_useDidUpdate.useDidUpdate;
+const unstable_useLayoutEffect = import_useLayoutEffect.useLayoutEffect;
+const unstable_useObserver = import_useObserver.useObserver;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unstable_useCompatEffect,
+  unstable_useCompatFactory,
+  unstable_useDidUpdate,
+  unstable_useForceUpdate,
+  unstable_useLayoutEffect,
+  unstable_useObserver
+});

package/lib/reactive-react/hooks/useCompatEffect.d.ts

@@ -0,0 +1,2 @@
+import { DependencyList, EffectCallback } from 'react';
+export declare const useCompatEffect: (effect: EffectCallback, deps?: DependencyList) => void;