@tachybase/schema 0.23.41 → 0.23.48

package/lib/reactive/autorun.js

@@ -0,0 +1,155 @@
+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 autorun_exports = {};
+__export(autorun_exports, {
+  autorun: () => autorun,
+  reaction: () => reaction
+});
+module.exports = __toCommonJS(autorun_exports);
+var import_array = require("./array");
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_reaction = require("./reaction");
+const autorun = /* @__PURE__ */ __name((tracker, name = "AutoRun") => {
+  const reaction2 = /* @__PURE__ */ __name(() => {
+    if (!(0, import_checkers.isFn)(tracker)) return;
+    if (reaction2._boundary > 0) return;
+    if (import_environment.ReactionStack.indexOf(reaction2) === -1) {
+      (0, import_reaction.releaseBindingReactions)(reaction2);
+      try {
+        (0, import_reaction.batchStart)();
+        import_environment.ReactionStack.push(reaction2);
+        tracker();
+      } finally {
+        import_environment.ReactionStack.pop();
+        reaction2._boundary++;
+        (0, import_reaction.batchEnd)();
+        reaction2._boundary = 0;
+        reaction2._memos.cursor = 0;
+        reaction2._effects.cursor = 0;
+      }
+    }
+  }, "reaction");
+  const cleanRefs = /* @__PURE__ */ __name(() => {
+    reaction2._memos = {
+      queue: [],
+      cursor: 0
+    };
+    reaction2._effects = {
+      queue: [],
+      cursor: 0
+    };
+  }, "cleanRefs");
+  reaction2._boundary = 0;
+  reaction2._name = name;
+  cleanRefs();
+  reaction2();
+  return () => {
+    (0, import_reaction.disposeBindingReactions)(reaction2);
+    (0, import_reaction.disposeEffects)(reaction2);
+    cleanRefs();
+  };
+}, "autorun");
+autorun.memo = (callback, dependencies) => {
+  if (!(0, import_checkers.isFn)(callback)) return;
+  const current = import_environment.ReactionStack[import_environment.ReactionStack.length - 1];
+  if (!current || !current._memos) throw new Error("autorun.memo must used in autorun function body.");
+  const deps = (0, import_array.toArray)(dependencies || []);
+  const id = current._memos.cursor++;
+  const old = current._memos.queue[id];
+  if (!old || (0, import_reaction.hasDepsChange)(deps, old.deps)) {
+    const value = callback();
+    current._memos.queue[id] = {
+      value,
+      deps
+    };
+    return value;
+  }
+  return old.value;
+};
+autorun.effect = (callback, dependencies) => {
+  if (!(0, import_checkers.isFn)(callback)) return;
+  const current = import_environment.ReactionStack[import_environment.ReactionStack.length - 1];
+  if (!current || !current._effects) throw new Error("autorun.effect must used in autorun function body.");
+  const effects = current._effects;
+  const deps = (0, import_array.toArray)(dependencies || [{}]);
+  const id = effects.cursor++;
+  const old = effects.queue[id];
+  if (!old || (0, import_reaction.hasDepsChange)(deps, old.deps)) {
+    Promise.resolve(0).then(() => {
+      if (current._disposed) return;
+      const dispose = callback();
+      if ((0, import_checkers.isFn)(dispose)) {
+        effects.queue[id].dispose = dispose;
+      }
+    });
+    effects.queue[id] = {
+      deps
+    };
+  }
+};
+const reaction = /* @__PURE__ */ __name((tracker, subscriber, options) => {
+  const realOptions = {
+    name: "Reaction",
+    ...options
+  };
+  const value = {};
+  const dirtyCheck = /* @__PURE__ */ __name(() => {
+    if ((0, import_checkers.isFn)(realOptions.equals)) return !realOptions.equals(value.oldValue, value.currentValue);
+    return value.oldValue !== value.currentValue;
+  }, "dirtyCheck");
+  const fireAction = /* @__PURE__ */ __name(() => {
+    try {
+      (0, import_reaction.batchStart)();
+      if ((0, import_checkers.isFn)(subscriber)) subscriber(value.currentValue, value.oldValue);
+    } finally {
+      (0, import_reaction.batchEnd)();
+    }
+  }, "fireAction");
+  const reaction2 = /* @__PURE__ */ __name(() => {
+    if (import_environment.ReactionStack.indexOf(reaction2) === -1) {
+      (0, import_reaction.releaseBindingReactions)(reaction2);
+      try {
+        import_environment.ReactionStack.push(reaction2);
+        value.currentValue = tracker();
+      } finally {
+        import_environment.ReactionStack.pop();
+      }
+    }
+  }, "reaction");
+  reaction2._scheduler = (looping) => {
+    looping();
+    if (dirtyCheck()) fireAction();
+    value.oldValue = value.currentValue;
+  };
+  reaction2._name = realOptions.name;
+  reaction2();
+  value.oldValue = value.currentValue;
+  if (realOptions.fireImmediately) {
+    fireAction();
+  }
+  return () => {
+    (0, import_reaction.disposeBindingReactions)(reaction2);
+  };
+}, "reaction");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autorun,
+  reaction
+});

package/lib/reactive/batch.d.ts

@@ -0,0 +1,2 @@
+import { IBatch } from './types';
+export declare const batch: IBatch;

package/lib/reactive/batch.js

@@ -0,0 +1,40 @@
+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 batch_exports = {};
+__export(batch_exports, {
+  batch: () => batch
+});
+module.exports = __toCommonJS(batch_exports);
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_internals = require("./internals");
+var import_reaction = require("./reaction");
+const batch = (0, import_internals.createBoundaryAnnotation)(import_reaction.batchStart, import_reaction.batchEnd);
+batch.scope = (0, import_internals.createBoundaryAnnotation)(import_reaction.batchScopeStart, import_reaction.batchScopeEnd);
+batch.endpoint = (callback) => {
+  if (!(0, import_checkers.isFn)(callback)) return;
+  if (import_environment.BatchCount.value === 0) {
+    callback();
+  } else {
+    import_environment.BatchEndpoints.add(callback);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  batch
+});

package/lib/reactive/checkers.d.ts

@@ -0,0 +1,10 @@
+export declare const isMap: (val: any) => val is Map<any, any>;
+export declare const isSet: (val: any) => val is Set<any>;
+export declare const isWeakMap: (val: any) => val is WeakMap<any, any>;
+export declare const isWeakSet: (val: any) => val is WeakSet<any>;
+export declare const isFn: (val: any) => val is Function;
+export declare const isArr: (arg: any) => arg is any[];
+export declare const isPlainObj: (val: any) => val is object;
+export declare const isValid: (val: any) => boolean;
+export declare const isCollectionType: (target: any) => target is Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any>;
+export declare const isNormalType: (target: any) => target is object | any[];

package/lib/reactive/checkers.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 checkers_exports = {};
+__export(checkers_exports, {
+  isArr: () => isArr,
+  isCollectionType: () => isCollectionType,
+  isFn: () => isFn,
+  isMap: () => isMap,
+  isNormalType: () => isNormalType,
+  isPlainObj: () => isPlainObj,
+  isSet: () => isSet,
+  isValid: () => isValid,
+  isWeakMap: () => isWeakMap,
+  isWeakSet: () => isWeakSet
+});
+module.exports = __toCommonJS(checkers_exports);
+const toString = Object.prototype.toString;
+const isMap = /* @__PURE__ */ __name((val) => val && val instanceof Map, "isMap");
+const isSet = /* @__PURE__ */ __name((val) => val && val instanceof Set, "isSet");
+const isWeakMap = /* @__PURE__ */ __name((val) => val && val instanceof WeakMap, "isWeakMap");
+const isWeakSet = /* @__PURE__ */ __name((val) => val && val instanceof WeakSet, "isWeakSet");
+const isFn = /* @__PURE__ */ __name((val) => typeof val === "function", "isFn");
+const isArr = Array.isArray;
+const isPlainObj = /* @__PURE__ */ __name((val) => toString.call(val) === "[object Object]", "isPlainObj");
+const isValid = /* @__PURE__ */ __name((val) => val !== null && val !== void 0, "isValid");
+const isCollectionType = /* @__PURE__ */ __name((target) => {
+  return isMap(target) || isWeakMap(target) || isSet(target) || isWeakSet(target);
+}, "isCollectionType");
+const isNormalType = /* @__PURE__ */ __name((target) => {
+  return isPlainObj(target) || isArr(target);
+}, "isNormalType");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isArr,
+  isCollectionType,
+  isFn,
+  isMap,
+  isNormalType,
+  isPlainObj,
+  isSet,
+  isValid,
+  isWeakMap,
+  isWeakSet
+});

package/lib/reactive/environment.d.ts

@@ -0,0 +1,28 @@
+import { ArraySet } from './array';
+import { DataNode } from './tree';
+import { ObservableListener, Reaction, ReactionsMap } from './types';
+export declare const ProxyRaw: WeakMap<WeakKey, any>;
+export declare const RawProxy: WeakMap<WeakKey, any>;
+export declare const RawShallowProxy: WeakMap<WeakKey, any>;
+export declare const RawNode: WeakMap<object, DataNode>;
+export declare const RawReactionsMap: WeakMap<object, ReactionsMap>;
+export declare const ReactionStack: Reaction[];
+export declare const BatchCount: {
+    value: number;
+};
+export declare const UntrackCount: {
+    value: number;
+};
+export declare const BatchScope: {
+    value: boolean;
+};
+export declare const DependencyCollected: {
+    value: boolean;
+};
+export declare const PendingReactions: ArraySet<Reaction>;
+export declare const PendingScopeReactions: ArraySet<Reaction>;
+export declare const BatchEndpoints: ArraySet<() => void>;
+export declare const ObserverListeners: ArraySet<ObservableListener>;
+export declare const MakeObModelSymbol: unique symbol;
+export declare const ObModelSymbol: unique symbol;
+export declare const ObModelNodeSymbol: unique symbol;

package/lib/reactive/environment.js

@@ -0,0 +1,76 @@
+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 environment_exports = {};
+__export(environment_exports, {
+  BatchCount: () => BatchCount,
+  BatchEndpoints: () => BatchEndpoints,
+  BatchScope: () => BatchScope,
+  DependencyCollected: () => DependencyCollected,
+  MakeObModelSymbol: () => MakeObModelSymbol,
+  ObModelNodeSymbol: () => ObModelNodeSymbol,
+  ObModelSymbol: () => ObModelSymbol,
+  ObserverListeners: () => ObserverListeners,
+  PendingReactions: () => PendingReactions,
+  PendingScopeReactions: () => PendingScopeReactions,
+  ProxyRaw: () => ProxyRaw,
+  RawNode: () => RawNode,
+  RawProxy: () => RawProxy,
+  RawReactionsMap: () => RawReactionsMap,
+  RawShallowProxy: () => RawShallowProxy,
+  ReactionStack: () => ReactionStack,
+  UntrackCount: () => UntrackCount
+});
+module.exports = __toCommonJS(environment_exports);
+var import_array = require("./array");
+const ProxyRaw = /* @__PURE__ */ new WeakMap();
+const RawProxy = /* @__PURE__ */ new WeakMap();
+const RawShallowProxy = /* @__PURE__ */ new WeakMap();
+const RawNode = /* @__PURE__ */ new WeakMap();
+const RawReactionsMap = /* @__PURE__ */ new WeakMap();
+const ReactionStack = [];
+const BatchCount = { value: 0 };
+const UntrackCount = { value: 0 };
+const BatchScope = { value: false };
+const DependencyCollected = { value: false };
+const PendingReactions = new import_array.ArraySet();
+const PendingScopeReactions = new import_array.ArraySet();
+const BatchEndpoints = new import_array.ArraySet();
+const ObserverListeners = new import_array.ArraySet();
+const MakeObModelSymbol = Symbol("MakeObModelSymbol");
+const ObModelSymbol = Symbol("ObModelSymbol");
+const ObModelNodeSymbol = Symbol("ObModelNodeSymbol");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchCount,
+  BatchEndpoints,
+  BatchScope,
+  DependencyCollected,
+  MakeObModelSymbol,
+  ObModelNodeSymbol,
+  ObModelSymbol,
+  ObserverListeners,
+  PendingReactions,
+  PendingScopeReactions,
+  ProxyRaw,
+  RawNode,
+  RawProxy,
+  RawReactionsMap,
+  RawShallowProxy,
+  ReactionStack,
+  UntrackCount
+});

package/lib/reactive/externals.d.ts

@@ -0,0 +1,10 @@
+import { Annotation } from './types';
+export declare const isObservable: (target: any) => boolean;
+export declare const isAnnotation: (target: any) => target is Annotation;
+export declare const isSupportObservable: (target: any) => boolean;
+export declare const markRaw: <T>(target: T) => T;
+export declare const markObservable: <T>(target: T) => T;
+export declare const raw: <T>(target: T) => T;
+export declare const toJS: <T>(values: T) => T;
+export declare const contains: (target: any, property: any) => any;
+export declare const hasCollected: (callback?: () => void) => boolean;

package/lib/reactive/externals.js

@@ -0,0 +1,156 @@
+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 externals_exports = {};
+__export(externals_exports, {
+  contains: () => contains,
+  hasCollected: () => hasCollected,
+  isAnnotation: () => isAnnotation,
+  isObservable: () => isObservable,
+  isSupportObservable: () => isSupportObservable,
+  markObservable: () => markObservable,
+  markRaw: () => markRaw,
+  raw: () => raw,
+  toJS: () => toJS
+});
+module.exports = __toCommonJS(externals_exports);
+var import_checkers = require("./checkers");
+var import_environment = require("./environment");
+var import_tree = require("./tree");
+const RAW_TYPE = Symbol("RAW_TYPE");
+const OBSERVABLE_TYPE = Symbol("OBSERVABLE_TYPE");
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const isObservable = /* @__PURE__ */ __name((target) => {
+  return import_environment.ProxyRaw.has(target) || !!(target == null ? void 0 : target[import_environment.ObModelSymbol]);
+}, "isObservable");
+const isAnnotation = /* @__PURE__ */ __name((target) => {
+  return target && !!target[import_environment.MakeObModelSymbol];
+}, "isAnnotation");
+const isSupportObservable = /* @__PURE__ */ __name((target) => {
+  if (!(0, import_checkers.isValid)(target)) return false;
+  if ((0, import_checkers.isArr)(target)) return true;
+  if ((0, import_checkers.isPlainObj)(target)) {
+    if (target[RAW_TYPE]) {
+      return false;
+    }
+    if (target[OBSERVABLE_TYPE]) {
+      return true;
+    }
+    if ("$$typeof" in target && "_owner" in target) {
+      return false;
+    }
+    if (target["_isAMomentObject"]) {
+      return false;
+    }
+    if (target["_isJSONSchemaObject"]) {
+      return false;
+    }
+    if ((0, import_checkers.isFn)(target["toJS"])) {
+      return false;
+    }
+    if ((0, import_checkers.isFn)(target["toJSON"])) {
+      return false;
+    }
+    return true;
+  }
+  if ((0, import_checkers.isMap)(target) || (0, import_checkers.isWeakMap)(target) || (0, import_checkers.isSet)(target) || (0, import_checkers.isWeakSet)(target)) return true;
+  return false;
+}, "isSupportObservable");
+const markRaw = /* @__PURE__ */ __name((target) => {
+  if (!target) return;
+  if ((0, import_checkers.isFn)(target)) {
+    target.prototype[RAW_TYPE] = true;
+  } else {
+    target[RAW_TYPE] = true;
+  }
+  return target;
+}, "markRaw");
+const markObservable = /* @__PURE__ */ __name((target) => {
+  if (!target) return;
+  if ((0, import_checkers.isFn)(target)) {
+    target.prototype[OBSERVABLE_TYPE] = true;
+  } else {
+    target[OBSERVABLE_TYPE] = true;
+  }
+  return target;
+}, "markObservable");
+const raw = /* @__PURE__ */ __name((target) => {
+  if (target == null ? void 0 : target[import_environment.ObModelSymbol]) return target[import_environment.ObModelSymbol];
+  return import_environment.ProxyRaw.get(target) || target;
+}, "raw");
+const toJS = /* @__PURE__ */ __name((values) => {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const _toJS = /* @__PURE__ */ __name((values2) => {
+    if (visited.has(values2)) {
+      return values2;
+    }
+    if (values2 && values2[RAW_TYPE]) return values2;
+    if ((0, import_checkers.isArr)(values2)) {
+      if (isObservable(values2)) {
+        visited.add(values2);
+        const res = [];
+        values2.forEach((item) => {
+          res.push(_toJS(item));
+        });
+        visited.delete(values2);
+        return res;
+      }
+    } else if ((0, import_checkers.isPlainObj)(values2)) {
+      if (isObservable(values2)) {
+        visited.add(values2);
+        const res = {};
+        for (const key in values2) {
+          if (hasOwnProperty.call(values2, key)) {
+            res[key] = _toJS(values2[key]);
+          }
+        }
+        visited.delete(values2);
+        return res;
+      }
+    }
+    return values2;
+  }, "_toJS");
+  return _toJS(values);
+}, "toJS");
+const contains = /* @__PURE__ */ __name((target, property) => {
+  const targetRaw = raw(target);
+  const propertyRaw = raw(property);
+  if (targetRaw === propertyRaw) return true;
+  const targetNode = (0, import_tree.getDataNode)(targetRaw);
+  const propertyNode = (0, import_tree.getDataNode)(propertyRaw);
+  if (!targetNode) return false;
+  if (!propertyNode) return false;
+  return targetNode.contains(propertyNode);
+}, "contains");
+const hasCollected = /* @__PURE__ */ __name((callback) => {
+  import_environment.DependencyCollected.value = false;
+  callback == null ? void 0 : callback();
+  return import_environment.DependencyCollected.value;
+}, "hasCollected");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  contains,
+  hasCollected,
+  isAnnotation,
+  isObservable,
+  isSupportObservable,
+  markObservable,
+  markRaw,
+  raw,
+  toJS
+});

package/lib/reactive/handlers.d.ts

@@ -0,0 +1,4 @@
+export declare const collectionHandlers: {
+    get(target: any, key: PropertyKey, receiver: any): any;
+};
+export declare const baseHandlers: ProxyHandler<any>;