@tachybase/schema 0.23.41 → 0.23.47

package/lib/reactive/annotations/box.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 box_exports = {};
+__export(box_exports, {
+  box: () => box
+});
+module.exports = __toCommonJS(box_exports);
+var import_environment = require("../environment");
+var import_internals = require("../internals");
+var import_reaction = require("../reaction");
+var import_tree = require("../tree");
+const box = (0, import_internals.createAnnotation)(({ target, key, value }) => {
+  const store = {
+    value: target ? target[key] : value
+  };
+  const proxy = {
+    set,
+    get
+  };
+  import_environment.ProxyRaw.set(proxy, store);
+  import_environment.RawProxy.set(store, proxy);
+  (0, import_tree.buildDataTree)(target, key, store);
+  function get() {
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({
+      target: store,
+      key,
+      type: "get"
+    });
+    return store.value;
+  }
+  __name(get, "get");
+  function set(value2) {
+    const oldValue = store.value;
+    store.value = value2;
+    if (oldValue !== value2) {
+      (0, import_reaction.runReactionsFromTargetKey)({
+        target: store,
+        key,
+        type: "set",
+        oldValue,
+        value: value2
+      });
+    }
+  }
+  __name(set, "set");
+  if (target) {
+    Object.defineProperty(target, key, {
+      value: proxy,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+    return target;
+  }
+  return proxy;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  box
+});

package/lib/reactive/annotations/computed.d.ts

@@ -0,0 +1,12 @@
+interface IValue<T = any> {
+    value?: T;
+}
+export interface IComputed {
+    <T>(compute: () => T): IValue<T>;
+    <T>(compute: {
+        get?: () => T;
+        set?: (value: T) => void;
+    }): IValue<T>;
+}
+export declare const computed: IComputed;
+export {};

package/lib/reactive/annotations/computed.js

@@ -0,0 +1,154 @@
+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 computed_exports = {};
+__export(computed_exports, {
+  computed: () => computed
+});
+module.exports = __toCommonJS(computed_exports);
+var import_checkers = require("../checkers");
+var import_environment = require("../environment");
+var import_internals = require("../internals");
+var import_reaction = require("../reaction");
+var import_tree = require("../tree");
+const getDescriptor = Object.getOwnPropertyDescriptor;
+const getProto = Object.getPrototypeOf;
+const ClassDescriptorSymbol = Symbol("ClassDescriptorSymbol");
+function getPropertyDescriptor(obj, key) {
+  if (!obj) return;
+  return getDescriptor(obj, key) || getPropertyDescriptor(getProto(obj), key);
+}
+__name(getPropertyDescriptor, "getPropertyDescriptor");
+function getPropertyDescriptorCache(obj, key) {
+  const constructor = obj.constructor;
+  if (constructor === Object || constructor === Array) return getPropertyDescriptor(obj, key);
+  const cache = constructor[ClassDescriptorSymbol] || {};
+  const descriptor = cache[key];
+  if (descriptor) return descriptor;
+  const newDesc = getPropertyDescriptor(obj, key);
+  constructor[ClassDescriptorSymbol] = cache;
+  cache[key] = newDesc;
+  return newDesc;
+}
+__name(getPropertyDescriptorCache, "getPropertyDescriptorCache");
+function getPrototypeDescriptor(target, key, value) {
+  if (!target) {
+    if (value) {
+      if ((0, import_checkers.isFn)(value)) {
+        return { get: value };
+      } else {
+        return value;
+      }
+    }
+    return {};
+  }
+  const descriptor = getPropertyDescriptorCache(target, key);
+  if (descriptor) {
+    return descriptor;
+  }
+  return {};
+}
+__name(getPrototypeDescriptor, "getPrototypeDescriptor");
+const computed = (0, import_internals.createAnnotation)(({ target, key, value }) => {
+  const store = {};
+  const proxy = {};
+  const context = target ? target : store;
+  const property = target ? key : "value";
+  const descriptor = getPrototypeDescriptor(target, property, value);
+  function compute() {
+    var _a;
+    store.value = (_a = descriptor.get) == null ? void 0 : _a.call(context);
+  }
+  __name(compute, "compute");
+  function reaction() {
+    if (import_environment.ReactionStack.indexOf(reaction) === -1) {
+      (0, import_reaction.releaseBindingReactions)(reaction);
+      try {
+        import_environment.ReactionStack.push(reaction);
+        compute();
+      } finally {
+        import_environment.ReactionStack.pop();
+      }
+    }
+  }
+  __name(reaction, "reaction");
+  reaction._name = "ComputedReaction";
+  reaction._scheduler = () => {
+    reaction._dirty = true;
+    (0, import_reaction.runReactionsFromTargetKey)({
+      target: context,
+      key: property,
+      value: store.value,
+      type: "set"
+    });
+  };
+  reaction._isComputed = true;
+  reaction._dirty = true;
+  reaction._context = context;
+  reaction._property = property;
+  function get() {
+    if ((0, import_reaction.hasRunningReaction)()) {
+      (0, import_reaction.bindComputedReactions)(reaction);
+    }
+    if (!(0, import_reaction.isUntracking)()) {
+      if (reaction._dirty) {
+        reaction();
+        reaction._dirty = false;
+      }
+    } else {
+      compute();
+    }
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({
+      target: context,
+      key: property,
+      type: "get"
+    });
+    return store.value;
+  }
+  __name(get, "get");
+  function set(value2) {
+    var _a;
+    try {
+      (0, import_reaction.batchStart)();
+      (_a = descriptor.set) == null ? void 0 : _a.call(context, value2);
+    } finally {
+      (0, import_reaction.batchEnd)();
+    }
+  }
+  __name(set, "set");
+  if (target) {
+    Object.defineProperty(target, key, {
+      get,
+      set,
+      enumerable: true
+    });
+    return target;
+  } else {
+    Object.defineProperty(proxy, "value", {
+      set,
+      get
+    });
+    (0, import_tree.buildDataTree)(target, key, store);
+    proxy[import_environment.ObModelSymbol] = store;
+  }
+  return proxy;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computed
+});

package/lib/reactive/annotations/index.d.ts

@@ -0,0 +1,5 @@
+export * from './observable';
+export * from './box';
+export * from './ref';
+export * from './shallow';
+export * from './computed';

package/lib/reactive/annotations/index.js

@@ -0,0 +1,29 @@
+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 annotations_exports = {};
+module.exports = __toCommonJS(annotations_exports);
+__reExport(annotations_exports, require("./observable"), module.exports);
+__reExport(annotations_exports, require("./box"), module.exports);
+__reExport(annotations_exports, require("./ref"), module.exports);
+__reExport(annotations_exports, require("./shallow"), module.exports);
+__reExport(annotations_exports, require("./computed"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./observable"),
+  ...require("./box"),
+  ...require("./ref"),
+  ...require("./shallow"),
+  ...require("./computed")
+});

package/lib/reactive/annotations/observable.d.ts

@@ -0,0 +1,4 @@
+export interface IObservable {
+    <T>(target: T): T;
+}
+export declare const observable: IObservable;

package/lib/reactive/annotations/observable.js

@@ -0,0 +1,67 @@
+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 observable_exports = {};
+__export(observable_exports, {
+  observable: () => observable
+});
+module.exports = __toCommonJS(observable_exports);
+var import_internals = require("../internals");
+var import_reaction = require("../reaction");
+const observable = (0, import_internals.createAnnotation)(({ target, key, value }) => {
+  const store = {
+    value: (0, import_internals.createObservable)(target, key, target ? target[key] : value)
+  };
+  function get() {
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({
+      target,
+      key,
+      type: "get"
+    });
+    return store.value;
+  }
+  __name(get, "get");
+  function set(value2) {
+    const oldValue = store.value;
+    value2 = (0, import_internals.createObservable)(target, key, value2);
+    store.value = value2;
+    if (oldValue === value2) return;
+    (0, import_reaction.runReactionsFromTargetKey)({
+      target,
+      key,
+      type: "set",
+      oldValue,
+      value: value2
+    });
+  }
+  __name(set, "set");
+  if (target) {
+    Object.defineProperty(target, key, {
+      set,
+      get,
+      enumerable: true,
+      configurable: false
+    });
+    return target;
+  }
+  return store.value;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  observable
+});

package/lib/reactive/annotations/ref.d.ts

@@ -0,0 +1,6 @@
+export interface IRef {
+    <T>(target: T): {
+        value: T;
+    };
+}
+export declare const ref: IRef;

package/lib/reactive/annotations/ref.js

@@ -0,0 +1,78 @@
+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 ref_exports = {};
+__export(ref_exports, {
+  ref: () => ref
+});
+module.exports = __toCommonJS(ref_exports);
+var import_environment = require("../environment");
+var import_internals = require("../internals");
+var import_reaction = require("../reaction");
+var import_tree = require("../tree");
+const ref = (0, import_internals.createAnnotation)(({ target, key, value }) => {
+  const store = {
+    value: target ? target[key] : value
+  };
+  const proxy = {};
+  const context = target ? target : store;
+  const property = target ? key : "value";
+  function get() {
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({
+      target: context,
+      key: property,
+      type: "get"
+    });
+    return store.value;
+  }
+  __name(get, "get");
+  function set(value2) {
+    const oldValue = store.value;
+    store.value = value2;
+    if (oldValue !== value2) {
+      (0, import_reaction.runReactionsFromTargetKey)({
+        target: context,
+        key: property,
+        type: "set",
+        oldValue,
+        value: value2
+      });
+    }
+  }
+  __name(set, "set");
+  if (target) {
+    Object.defineProperty(target, key, {
+      get,
+      set,
+      enumerable: true
+    });
+    return target;
+  } else {
+    Object.defineProperty(proxy, "value", {
+      set,
+      get
+    });
+    (0, import_tree.buildDataTree)(target, key, store);
+    proxy[import_environment.ObModelSymbol] = store;
+  }
+  return proxy;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ref
+});

package/lib/reactive/annotations/shallow.d.ts

@@ -0,0 +1,2 @@
+import { IObservable } from './observable';
+export declare const shallow: IObservable;

package/lib/reactive/annotations/shallow.js

@@ -0,0 +1,67 @@
+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 shallow_exports = {};
+__export(shallow_exports, {
+  shallow: () => shallow
+});
+module.exports = __toCommonJS(shallow_exports);
+var import_internals = require("../internals");
+var import_reaction = require("../reaction");
+const shallow = (0, import_internals.createAnnotation)(({ target, key, value }) => {
+  const store = {
+    value: (0, import_internals.createObservable)(target, key, target ? target[key] : value, true)
+  };
+  function get() {
+    (0, import_reaction.bindTargetKeyWithCurrentReaction)({
+      target,
+      key,
+      type: "get"
+    });
+    return store.value;
+  }
+  __name(get, "get");
+  function set(value2) {
+    const oldValue = store.value;
+    value2 = (0, import_internals.createObservable)(target, key, value2, true);
+    store.value = value2;
+    if (oldValue === value2) return;
+    (0, import_reaction.runReactionsFromTargetKey)({
+      target,
+      key,
+      type: "set",
+      oldValue,
+      value: value2
+    });
+  }
+  __name(set, "set");
+  if (target) {
+    Object.defineProperty(target, key, {
+      set,
+      get,
+      enumerable: true,
+      configurable: false
+    });
+    return target;
+  }
+  return store.value;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shallow
+});

package/lib/reactive/array.d.ts

@@ -0,0 +1,12 @@
+export declare const toArray: (value: any) => any[];
+export declare class ArraySet<T> {
+    value: T[];
+    forEachIndex: number;
+    constructor(value?: T[]);
+    add(item: T): void;
+    has(item: T): boolean;
+    delete(item: T): void;
+    forEach(callback: (value: T) => void): void;
+    batchDelete(callback: (value: T) => void): void;
+    clear(): void;
+}

package/lib/reactive/array.js

@@ -0,0 +1,83 @@
+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 array_exports = {};
+__export(array_exports, {
+  ArraySet: () => ArraySet,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(array_exports);
+const toArray = /* @__PURE__ */ __name((value) => {
+  return Array.isArray(value) ? value : value !== void 0 && value !== null ? [value] : [];
+}, "toArray");
+const _ArraySet = class _ArraySet {
+  constructor(value = []) {
+    this.forEachIndex = 0;
+    this.value = value;
+  }
+  add(item) {
+    if (!this.has(item)) {
+      this.value.push(item);
+    }
+  }
+  has(item) {
+    return this.value.indexOf(item) > -1;
+  }
+  delete(item) {
+    const len = this.value.length;
+    if (len === 0) return;
+    if (len === 1 && this.value[0] === item) {
+      this.value = [];
+      return;
+    }
+    const findIndex = this.value.indexOf(item);
+    if (findIndex > -1) {
+      this.value.splice(findIndex, 1);
+      if (findIndex <= this.forEachIndex) {
+        this.forEachIndex -= 1;
+      }
+    }
+  }
+  forEach(callback) {
+    if (this.value.length === 0) return;
+    this.forEachIndex = 0;
+    for (; this.forEachIndex < this.value.length; this.forEachIndex++) {
+      callback(this.value[this.forEachIndex]);
+    }
+  }
+  batchDelete(callback) {
+    if (this.value.length === 0) return;
+    this.forEachIndex = 0;
+    for (; this.forEachIndex < this.value.length; this.forEachIndex++) {
+      const value = this.value[this.forEachIndex];
+      this.value.splice(this.forEachIndex, 1);
+      this.forEachIndex--;
+      callback(value);
+    }
+  }
+  clear() {
+    this.value.length = 0;
+  }
+};
+__name(_ArraySet, "ArraySet");
+let ArraySet = _ArraySet;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArraySet,
+  toArray
+});

package/lib/reactive/autorun.d.ts

@@ -0,0 +1,7 @@
+import { Dispose, IReactionOptions, Reaction } from './types';
+export declare const autorun: {
+    (tracker: Reaction, name?: string): () => void;
+    memo<T>(callback: () => T, dependencies?: any[]): T;
+    effect(callback: () => void | Dispose, dependencies?: any[]): void;
+};
+export declare const reaction: <T>(tracker: () => T, subscriber?: (value: T, oldValue: T) => void, options?: IReactionOptions<T>) => () => void;