@tachybase/schema 0.23.41 → 0.23.48

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

@@ -0,0 +1,60 @@
+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 useCompatEffect_exports = {};
+__export(useCompatEffect_exports, {
+  useCompatEffect: () => useCompatEffect
+});
+module.exports = __toCommonJS(useCompatEffect_exports);
+var import_react = require("react");
+var import_shared = require("../shared");
+const isArr = Array.isArray;
+const isEqualDeps = /* @__PURE__ */ __name((target, source) => {
+  const arrA = isArr(target);
+  const arrB = isArr(source);
+  if (arrA !== arrB) return false;
+  if (arrA) {
+    if (target.length !== source.length) return false;
+    return target.every((val, index) => val === source[index]);
+  }
+  return target === source;
+}, "isEqualDeps");
+const useCompatEffect = /* @__PURE__ */ __name((effect, deps) => {
+  const depsRef = (0, import_react.useRef)(null);
+  const mountedRef = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    mountedRef.current = true;
+    const dispose = effect();
+    return () => {
+      mountedRef.current = false;
+      if (!isEqualDeps(depsRef.current, deps)) {
+        if (dispose) dispose();
+        return;
+      }
+      (0, import_shared.immediate)(() => {
+        if (mountedRef.current) return;
+        if (dispose) dispose();
+      });
+    };
+  }, deps);
+  depsRef.current = deps;
+}, "useCompatEffect");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCompatEffect
+});

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

@@ -0,0 +1,3 @@
+export declare const useCompatFactory: <T extends {
+    dispose: () => void;
+}>(factory: () => T) => T;

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

@@ -0,0 +1,74 @@
+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 useCompatFactory_exports = {};
+__export(useCompatFactory_exports, {
+  useCompatFactory: () => useCompatFactory
+});
+module.exports = __toCommonJS(useCompatFactory_exports);
+var import_react = __toESM(require("react"));
+var import_shared = require("../shared");
+var import_useCompatEffect = require("./useCompatEffect");
+const _ObjectToBeRetainedByReact = class _ObjectToBeRetainedByReact {
+};
+__name(_ObjectToBeRetainedByReact, "ObjectToBeRetainedByReact");
+let ObjectToBeRetainedByReact = _ObjectToBeRetainedByReact;
+function objectToBeRetainedByReactFactory() {
+  return new ObjectToBeRetainedByReact();
+}
+__name(objectToBeRetainedByReactFactory, "objectToBeRetainedByReactFactory");
+const useCompatFactory = /* @__PURE__ */ __name((factory) => {
+  const instRef = import_react.default.useRef(null);
+  const gcRef = import_react.default.useRef();
+  const [objectRetainedByReact] = import_react.default.useState(objectToBeRetainedByReactFactory);
+  if (!instRef.current) {
+    instRef.current = factory();
+  }
+  if (!gcRef.current) {
+    gcRef.current = new import_shared.GarbageCollector(() => {
+      if (instRef.current) {
+        instRef.current.dispose();
+      }
+    });
+    gcRef.current.open(objectRetainedByReact);
+  }
+  (0, import_useCompatEffect.useCompatEffect)(() => {
+    gcRef.current.close();
+    return () => {
+      if (instRef.current) {
+        instRef.current.dispose();
+        instRef.current = null;
+      }
+    };
+  }, []);
+  return instRef.current;
+}, "useCompatFactory");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCompatFactory
+});

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

@@ -0,0 +1 @@
+export declare const useDidUpdate: (callback?: () => void) => void;

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

@@ -0,0 +1,38 @@
+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 useDidUpdate_exports = {};
+__export(useDidUpdate_exports, {
+  useDidUpdate: () => useDidUpdate
+});
+module.exports = __toCommonJS(useDidUpdate_exports);
+var import_react = require("react");
+var import_shared = require("../shared");
+var import_useLayoutEffect = require("./useLayoutEffect");
+const useDidUpdate = /* @__PURE__ */ __name((callback) => {
+  const request = (0, import_react.useRef)(null);
+  request.current = (0, import_shared.immediate)(callback);
+  (0, import_useLayoutEffect.useLayoutEffect)(() => {
+    request.current();
+    callback();
+  });
+}, "useDidUpdate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDidUpdate
+});

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

@@ -0,0 +1 @@
+export declare function useForceUpdate(): () => void;

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

@@ -0,0 +1,76 @@
+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 useForceUpdate_exports = {};
+__export(useForceUpdate_exports, {
+  useForceUpdate: () => useForceUpdate
+});
+module.exports = __toCommonJS(useForceUpdate_exports);
+var import_react = require("react");
+var import_useDidUpdate = require("./useDidUpdate");
+var import_useLayoutEffect = require("./useLayoutEffect");
+const EMPTY_ARRAY = [];
+const RENDER_COUNT = { value: 0 };
+const RENDER_QUEUE = /* @__PURE__ */ new Set();
+function useForceUpdate() {
+  const [, setState] = (0, import_react.useState)([]);
+  const firstRenderedRef = (0, import_react.useRef)(false);
+  const needUpdateRef = (0, import_react.useRef)(false);
+  (0, import_useLayoutEffect.useLayoutEffect)(() => {
+    firstRenderedRef.current = true;
+    if (needUpdateRef.current) {
+      setState([]);
+      needUpdateRef.current = false;
+    }
+    return () => {
+      firstRenderedRef.current = false;
+    };
+  }, EMPTY_ARRAY);
+  const update = (0, import_react.useCallback)(() => {
+    setState([]);
+  }, EMPTY_ARRAY);
+  const scheduler = (0, import_react.useCallback)(() => {
+    if (!firstRenderedRef.current) {
+      needUpdateRef.current = true;
+      return;
+    }
+    if (RENDER_COUNT.value === 0) {
+      update();
+    } else {
+      RENDER_QUEUE.add(update);
+    }
+  }, EMPTY_ARRAY);
+  RENDER_COUNT.value++;
+  (0, import_useDidUpdate.useDidUpdate)(() => {
+    if (RENDER_COUNT.value > 0) {
+      RENDER_COUNT.value--;
+    }
+    if (RENDER_COUNT.value === 0) {
+      RENDER_QUEUE.forEach((update2) => {
+        RENDER_QUEUE.delete(update2);
+        update2();
+      });
+    }
+  });
+  return scheduler;
+}
+__name(useForceUpdate, "useForceUpdate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useForceUpdate
+});

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

@@ -0,0 +1,2 @@
+import { useEffect } from 'react';
+export declare const useLayoutEffect: typeof useEffect;

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

@@ -0,0 +1,28 @@
+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 useLayoutEffect_exports = {};
+__export(useLayoutEffect_exports, {
+  useLayoutEffect: () => useLayoutEffect
+});
+module.exports = __toCommonJS(useLayoutEffect_exports);
+var import_react = require("react");
+const useLayoutEffect = typeof document !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLayoutEffect
+});

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

@@ -0,0 +1,2 @@
+import { IObserverOptions } from '../types';
+export declare const useObserver: <T extends () => any>(view: T, options?: IObserverOptions) => ReturnType<T>;

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

@@ -0,0 +1,43 @@
+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 useObserver_exports = {};
+__export(useObserver_exports, {
+  useObserver: () => useObserver
+});
+module.exports = __toCommonJS(useObserver_exports);
+var import_reactive = require("../../reactive");
+var import_useCompatFactory = require("./useCompatFactory");
+var import_useForceUpdate = require("./useForceUpdate");
+const useObserver = /* @__PURE__ */ __name((view, options) => {
+  const forceUpdate = (0, import_useForceUpdate.useForceUpdate)();
+  const tracker = (0, import_useCompatFactory.useCompatFactory)(
+    () => new import_reactive.Tracker(() => {
+      if (typeof (options == null ? void 0 : options.scheduler) === "function") {
+        options.scheduler(forceUpdate);
+      } else {
+        forceUpdate();
+      }
+    }, options == null ? void 0 : options.displayName)
+  );
+  return tracker.track(view);
+}, "useObserver");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useObserver
+});

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

@@ -0,0 +1,3 @@
+export * from './observer';
+export * from './hooks';
+export * from './types';

package/lib/reactive-react/index.js

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

package/lib/reactive-react/observer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { IObserverOptions, IObserverProps, ReactFC } from './types';
+export declare function observer<P, Options extends IObserverOptions = IObserverOptions>(component: ReactFC<P>, options?: Options): React.MemoExoticComponent<ReactFC<Options extends {
+    forwardRef: true;
+} ? P & {
+    ref?: 'ref' extends keyof P ? P['ref'] : React.RefAttributes<any>;
+} : React.PropsWithoutRef<P>>>;
+export declare const Observer: React.MemoExoticComponent<ReactFC<IObserverProps>>;

package/lib/reactive-react/observer.js

@@ -0,0 +1,64 @@
+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 observer_exports = {};
+__export(observer_exports, {
+  Observer: () => Observer,
+  observer: () => observer
+});
+module.exports = __toCommonJS(observer_exports);
+var import_react = __toESM(require("react"));
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+var import_useObserver = require("./hooks/useObserver");
+function observer(component, options) {
+  const realOptions = {
+    forwardRef: false,
+    ...options
+  };
+  const wrappedComponent = realOptions.forwardRef ? (0, import_react.forwardRef)((props, ref) => {
+    return (0, import_useObserver.useObserver)(() => component({ ...props, ref }), realOptions);
+  }) : (props) => {
+    return (0, import_useObserver.useObserver)(() => component(props), realOptions);
+  };
+  const memoComponent = (0, import_react.memo)(wrappedComponent);
+  (0, import_hoist_non_react_statics.default)(memoComponent, component);
+  if (realOptions.displayName) {
+    memoComponent.displayName = realOptions.displayName;
+  }
+  return memoComponent;
+}
+__name(observer, "observer");
+const Observer = observer((props) => {
+  const children = typeof props.children === "function" ? props.children() : props.children;
+  return import_react.default.createElement(import_react.Fragment, {}, children);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Observer,
+  observer
+});

package/lib/reactive-react/shared/gc.d.ts

@@ -0,0 +1,8 @@
+export declare class GarbageCollector<T extends object = any> {
+    private expireTime;
+    private request?;
+    private token;
+    constructor(clean?: () => void, expireTime?: number);
+    open(target: T): void;
+    close(): void;
+}

package/lib/reactive-react/shared/gc.js

@@ -0,0 +1,59 @@
+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 gc_exports = {};
+__export(gc_exports, {
+  GarbageCollector: () => GarbageCollector
+});
+module.exports = __toCommonJS(gc_exports);
+var import_global = require("./global");
+const registry = import_global.globalThisPolyfill["FinalizationRegistry"] && new import_global.globalThisPolyfill["FinalizationRegistry"]((token) => {
+  var _a;
+  return (_a = token == null ? void 0 : token.clean) == null ? void 0 : _a.call(token);
+});
+const _GarbageCollector = class _GarbageCollector {
+  constructor(clean, expireTime = 1e4) {
+    this.token = {
+      clean
+    };
+    this.expireTime = expireTime;
+  }
+  open(target) {
+    if (registry) {
+      registry.register(target, this.token, this.token);
+    } else {
+      this.request = setTimeout(() => {
+        var _a, _b;
+        (_b = (_a = this.token) == null ? void 0 : _a.clean) == null ? void 0 : _b.call(_a);
+      }, this.expireTime);
+    }
+  }
+  close() {
+    if (registry) {
+      registry.unregister(this.token);
+    } else {
+      clearTimeout(this.request);
+    }
+  }
+};
+__name(_GarbageCollector, "GarbageCollector");
+let GarbageCollector = _GarbageCollector;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GarbageCollector
+});

package/lib/reactive-react/shared/global.d.ts

@@ -0,0 +1 @@
+export declare const globalThisPolyfill: Window;

package/lib/reactive-react/shared/global.js

@@ -0,0 +1,50 @@
+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 global_exports = {};
+__export(global_exports, {
+  globalThisPolyfill: () => globalThisPolyfill
+});
+module.exports = __toCommonJS(global_exports);
+function globalSelf() {
+  try {
+    if (typeof self !== "undefined") {
+      return self;
+    }
+  } catch (e) {
+  }
+  try {
+    if (typeof window !== "undefined") {
+      return window;
+    }
+  } catch (e) {
+  }
+  try {
+    if (typeof global !== "undefined") {
+      return global;
+    }
+  } catch (e) {
+  }
+  return Function("return this")();
+}
+__name(globalSelf, "globalSelf");
+const globalThisPolyfill = globalSelf();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  globalThisPolyfill
+});

package/lib/reactive-react/shared/immediate.d.ts

@@ -0,0 +1 @@
+export declare const immediate: (callback?: () => void) => () => void;

package/lib/reactive-react/shared/immediate.js

@@ -0,0 +1,40 @@
+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 immediate_exports = {};
+__export(immediate_exports, {
+  immediate: () => immediate
+});
+module.exports = __toCommonJS(immediate_exports);
+const immediate = /* @__PURE__ */ __name((callback) => {
+  let disposed = false;
+  Promise.resolve(0).then(() => {
+    if (disposed) {
+      disposed = false;
+      return;
+    }
+    callback();
+  });
+  return () => {
+    disposed = true;
+  };
+}, "immediate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  immediate
+});

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

@@ -0,0 +1,2 @@
+export * from './gc';
+export * from './immediate';

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

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

package/lib/reactive-react/types.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface IObserverOptions {
+    forwardRef?: boolean;
+    scheduler?: (updater: () => void) => void;
+    displayName?: string;
+}
+export interface IObserverProps {
+    children?: (() => React.ReactElement) | React.ReactNode;
+}
+export type Modify<T, R> = Omit<T, keyof R> & R;
+export type ReactPropsWithChildren<P> = Modify<{
+    children?: React.ReactNode | undefined;
+}, P>;
+export type ReactFC<P = {}> = React.FC<ReactPropsWithChildren<P>>;