@tachybase/schema 0.23.40 → 0.23.47

package/lib/index.js

@@ -2,7 +2,6 @@ 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 });
@@ -26,7 +25,7 @@ __export(src_exports, {
   FormConsumer: () => import_react.FormConsumer,
   FormContext: () => import_react.FormContext,
   FormProvider: () => import_react.FormProvider,
-  NumberIndexReg: () => NumberIndexReg,
+  NumberIndexReg: () => import_constants.NumberIndexReg,
   ObjectFieldComponent: () => import_react.ObjectField,
   RecordScope: () => import_react.RecordScope,
   RecordsScope: () => import_react.RecordsScope,
@@ -36,18 +35,18 @@ __export(src_exports, {
   SchemaExpressionScopeContext: () => import_react.SchemaExpressionScopeContext,
   SchemaOptionsContext: () => import_react.SchemaOptionsContext,
   VoidFieldComponent: () => import_react.VoidField,
-  buildDataPath: () => buildDataPath,
-  buildFieldPath: () => buildFieldPath,
+  buildDataPath: () => import_internals.buildDataPath,
+  buildFieldPath: () => import_internals.buildFieldPath,
   connect: () => import_react.connect,
   createSchemaField: () => import_react.createSchemaField,
-  destroy: () => destroy,
-  exchangeArrayState: () => exchangeArrayState,
-  locateNode: () => locateNode,
+  destroy: () => import_internals.destroy,
+  exchangeArrayState: () => import_internals.exchangeArrayState,
+  locateNode: () => import_internals.locateNode,
   mapProps: () => import_react.mapProps,
   mapReadPretty: () => import_react.mapReadPretty,
-  patchFieldStates: () => patchFieldStates,
-  spliceArrayState: () => spliceArrayState,
-  useAttach: () => useAttach,
+  patchFieldStates: () => import_internals.patchFieldStates,
+  spliceArrayState: () => import_internals.spliceArrayState,
+  useAttach: () => import_useAttach.useAttach,
   useExpressionScope: () => import_react.useExpressionScope,
   useField: () => import_react.useField,
   useFieldSchema: () => import_react.useFieldSchema,
@@ -56,233 +55,17 @@ __export(src_exports, {
   useParentForm: () => import_react.useParentForm
 });
 module.exports = __toCommonJS(src_exports);
-var import_core = require("@formily/core");
-var import_reactive = require("@formily/reactive");
-var import_reactive_react = require("@formily/reactive-react");
-var import_shared = require("@formily/shared");
-__reExport(src_exports, require("@formily/core"), module.exports);
-__reExport(src_exports, require("@formily/grid"), module.exports);
-__reExport(src_exports, require("@formily/json-schema"), module.exports);
-var import_react = require("@formily/react");
-__reExport(src_exports, require("@formily/reactive"), module.exports);
-__reExport(src_exports, require("@formily/reactive-react"), module.exports);
-__reExport(src_exports, require("@formily/shared"), module.exports);
-__reExport(src_exports, require("@formily/validator"), module.exports);
-const useAttach = /* @__PURE__ */ __name((target) => {
-  (0, import_reactive_react.unstable_useCompatEffect)(() => {
-    target.onMount();
-    return () => target.onUnmount();
-  }, [target]);
-  return target;
-}, "useAttach");
-const NumberIndexReg = /^\.(\d+)/;
-const exchangeArrayState = /* @__PURE__ */ __name((field, props) => {
-  const { fromIndex, toIndex } = {
-    fromIndex: 0,
-    toIndex: 0,
-    ...props
-  };
-  const address = field.address.toString();
-  const fields = field.form.fields;
-  const addrLength = address.length;
-  const fieldPatches = [];
-  const isArrayChildren = /* @__PURE__ */ __name((identifier) => {
-    return identifier.indexOf(address) === 0 && identifier.length > addrLength;
-  }, "isArrayChildren");
-  const isDown = fromIndex < toIndex;
-  const isMoveNode = /* @__PURE__ */ __name((identifier) => {
-    var _a;
-    const afterStr = identifier.slice(address.length);
-    const number = (_a = afterStr.match(NumberIndexReg)) == null ? void 0 : _a[1];
-    if (number === void 0) return false;
-    const index = Number(number);
-    return isDown ? index > fromIndex && index <= toIndex : index < fromIndex && index >= toIndex;
-  }, "isMoveNode");
-  const isFromNode = /* @__PURE__ */ __name((identifier) => {
-    var _a;
-    const afterStr = identifier.substring(addrLength);
-    const number = (_a = afterStr.match(NumberIndexReg)) == null ? void 0 : _a[1];
-    if (number === void 0) return false;
-    const index = Number(number);
-    return index === fromIndex;
-  }, "isFromNode");
-  const moveIndex = /* @__PURE__ */ __name((identifier) => {
-    const preStr = identifier.substring(0, addrLength);
-    const afterStr = identifier.substring(addrLength);
-    const number = afterStr.match(NumberIndexReg)[1];
-    const current = Number(number);
-    let index = current;
-    if (index === fromIndex) {
-      index = toIndex;
-    } else {
-      index += isDown ? -1 : 1;
-    }
-    return `${preStr}${afterStr.replace(/^\.\d+/, `.${index}`)}`;
-  }, "moveIndex");
-  (0, import_reactive.batch)(() => {
-    (0, import_shared.each)(fields, (field2, identifier) => {
-      if (isArrayChildren(identifier)) {
-        if (isMoveNode(identifier) || isFromNode(identifier)) {
-          const newIdentifier = moveIndex(identifier);
-          fieldPatches.push({
-            type: "update",
-            address: newIdentifier,
-            oldAddress: identifier,
-            payload: field2
-          });
-          if (!fields[newIdentifier]) {
-            fieldPatches.push({
-              type: "remove",
-              address: identifier
-            });
-          }
-        }
-      }
-    });
-    patchFieldStates(fields, fieldPatches);
-  });
-  field.form.notify(import_core.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
-}, "exchangeArrayState");
-const patchFieldStates = /* @__PURE__ */ __name((target, patches) => {
-  patches.forEach(({ type, address, oldAddress, payload }) => {
-    if (type === "remove") {
-      destroy(target, address, false);
-    } else if (type === "update") {
-      if (payload) {
-        target[address] = payload;
-        if (target[oldAddress] === payload) {
-          target[oldAddress] = void 0;
-        }
-      }
-      if (address && payload) {
-        locateNode(payload, address);
-      }
-    }
-  });
-}, "patchFieldStates");
-const destroy = /* @__PURE__ */ __name((target, address, forceClear = true) => {
-  const field = target[address];
-  field == null ? void 0 : field.dispose();
-  if ((0, import_core.isDataField)(field) && forceClear) {
-    const form = field.form;
-    const path = field.path;
-    form.deleteValuesIn(path);
-    form.deleteInitialValuesIn(path);
-  }
-  delete target[address];
-}, "destroy");
-const locateNode = /* @__PURE__ */ __name((field, address) => {
-  field.address = import_shared.FormPath.parse(address);
-  field.path = buildFieldPath(field);
-  field.form.indexes[field.path.toString()] = field.address.toString();
-  return field;
-}, "locateNode");
-const buildFieldPath = /* @__PURE__ */ __name((field) => {
-  return buildDataPath(field.form.fields, field.address);
-}, "buildFieldPath");
-const buildDataPath = /* @__PURE__ */ __name((fields, pattern) => {
-  let prevArray = false;
-  const segments = pattern.segments;
-  const path = segments.reduce((path2, key, index) => {
-    const currentPath = path2.concat(key);
-    const currentAddress = segments.slice(0, index + 1);
-    const current = fields[currentAddress.join(".")];
-    if (prevArray) {
-      if (!(0, import_core.isVoidField)(current)) {
-        prevArray = false;
-      }
-      return path2;
-    }
-    if (index >= segments.length - 1) {
-      return currentPath;
-    }
-    if ((0, import_core.isVoidField)(current)) {
-      const parentAddress = segments.slice(0, index);
-      const parent = fields[parentAddress.join(".")];
-      if ((0, import_core.isArrayField)(parent) && (0, import_shared.isNumberLike)(key)) {
-        prevArray = true;
-        return currentPath;
-      }
-      return path2;
-    } else {
-      prevArray = false;
-    }
-    return currentPath;
-  }, []);
-  return new import_shared.FormPath(path);
-}, "buildDataPath");
-const spliceArrayState = /* @__PURE__ */ __name((field, props) => {
-  const { startIndex, deleteCount, insertCount } = {
-    startIndex: 0,
-    deleteCount: 0,
-    insertCount: 0,
-    ...props
-  };
-  const address = field.address.toString();
-  const addrLength = address.length;
-  const form = field.form;
-  const fields = form.fields;
-  const fieldPatches = [];
-  const offset = insertCount - deleteCount;
-  const isArrayChildren = /* @__PURE__ */ __name((identifier) => {
-    return identifier.indexOf(address) === 0 && identifier.length > addrLength;
-  }, "isArrayChildren");
-  const isAfterNode = /* @__PURE__ */ __name((identifier) => {
-    var _a;
-    const afterStr = identifier.substring(addrLength);
-    const number = (_a = afterStr.match(NumberIndexReg)) == null ? void 0 : _a[1];
-    if (number === void 0) return false;
-    const index = Number(number);
-    return index > startIndex + deleteCount - 1;
-  }, "isAfterNode");
-  const isInsertNode = /* @__PURE__ */ __name((identifier) => {
-    var _a;
-    const afterStr = identifier.substring(addrLength);
-    const number = (_a = afterStr.match(NumberIndexReg)) == null ? void 0 : _a[1];
-    if (number === void 0) return false;
-    const index = Number(number);
-    return index >= startIndex && index < startIndex + insertCount;
-  }, "isInsertNode");
-  const isDeleteNode = /* @__PURE__ */ __name((identifier) => {
-    var _a;
-    const preStr = identifier.substring(0, addrLength);
-    const afterStr = identifier.substring(addrLength);
-    const number = (_a = afterStr.match(NumberIndexReg)) == null ? void 0 : _a[1];
-    if (number === void 0) return false;
-    const index = Number(number);
-    return index > startIndex && !fields[`${preStr}${afterStr.replace(/^\.\d+/, `.${index + deleteCount}`)}`] || index === startIndex;
-  }, "isDeleteNode");
-  const moveIndex = /* @__PURE__ */ __name((identifier) => {
-    var _a;
-    if (offset === 0) return identifier;
-    const preStr = identifier.substring(0, addrLength);
-    const afterStr = identifier.substring(addrLength);
-    const number = (_a = afterStr.match(NumberIndexReg)) == null ? void 0 : _a[1];
-    if (number === void 0) return identifier;
-    const index = Number(number) + offset;
-    return `${preStr}${afterStr.replace(/^\.\d+/, `.${index}`)}`;
-  }, "moveIndex");
-  (0, import_reactive.batch)(() => {
-    (0, import_shared.each)(fields, (field2, identifier) => {
-      if (isArrayChildren(identifier)) {
-        if (isAfterNode(identifier)) {
-          const newIdentifier = moveIndex(identifier);
-          fieldPatches.push({
-            type: "update",
-            address: newIdentifier,
-            oldAddress: identifier,
-            payload: field2
-          });
-        }
-        if (isInsertNode(identifier) || isDeleteNode(identifier)) {
-          fieldPatches.push({ type: "remove", address: identifier });
-        }
-      }
-    });
-    patchFieldStates(fields, fieldPatches);
-  });
-  field.form.notify(import_core.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
-}, "spliceArrayState");
+var import_internals = require("./core/shared/internals");
+var import_constants = require("./core/shared/constants");
+var import_useAttach = require("./react/hooks/useAttach");
+__reExport(src_exports, require("./core"), module.exports);
+__reExport(src_exports, require("./grid"), module.exports);
+__reExport(src_exports, require("./json-schema"), module.exports);
+var import_react = require("./react");
+__reExport(src_exports, require("./reactive"), module.exports);
+__reExport(src_exports, require("./reactive-react"), module.exports);
+__reExport(src_exports, require("./shared"), module.exports);
+__reExport(src_exports, require("./validator"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArrayFieldComponent,
@@ -320,11 +103,11 @@ const spliceArrayState = /* @__PURE__ */ __name((field, props) => {
   useForm,
   useFormEffects,
   useParentForm,
-  ...require("@formily/core"),
-  ...require("@formily/grid"),
-  ...require("@formily/json-schema"),
-  ...require("@formily/reactive"),
-  ...require("@formily/reactive-react"),
-  ...require("@formily/shared"),
-  ...require("@formily/validator")
+  ...require("./core"),
+  ...require("./grid"),
+  ...require("./json-schema"),
+  ...require("./reactive"),
+  ...require("./reactive-react"),
+  ...require("./shared"),
+  ...require("./validator")
 });

package/lib/json-schema/compiler.d.ts

@@ -0,0 +1,8 @@
+import { IGeneralFieldState } from '../core';
+import { ISchema } from './types';
+export declare const silent: (value?: boolean) => void;
+export declare const registerCompiler: (compiler: (expression: string, scope: any) => any) => void;
+export declare const shallowCompile: <Source = any, Scope = any>(source: Source, scope?: Scope) => any;
+export declare const compile: <Source = any, Scope = any>(source: Source, scope?: Scope) => any;
+export declare const patchCompile: (targetState: IGeneralFieldState, sourceState: any, scope: any) => void;
+export declare const patchSchemaCompile: (targetState: IGeneralFieldState, sourceSchema: ISchema, scope: any, demand?: boolean) => void;

package/lib/json-schema/compiler.js

@@ -0,0 +1,129 @@
+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 compiler_exports = {};
+__export(compiler_exports, {
+  compile: () => compile,
+  patchCompile: () => patchCompile,
+  patchSchemaCompile: () => patchSchemaCompile,
+  registerCompiler: () => registerCompiler,
+  shallowCompile: () => shallowCompile,
+  silent: () => silent
+});
+module.exports = __toCommonJS(compiler_exports);
+var import_reactive = require("../reactive");
+var import_shared = require("../shared");
+var import_shared2 = require("./shared");
+const ExpRE = /^\s*\{\{([\s\S]*)\}\}\s*$/;
+const Registry = {
+  silent: false,
+  compile(expression, scope = {}) {
+    if (Registry.silent) {
+      try {
+        return new Function("$root", `with($root) { return (${expression}); }`)(scope);
+      } catch {
+      }
+    } else {
+      return new Function("$root", `with($root) { return (${expression}); }`)(scope);
+    }
+  }
+};
+const silent = /* @__PURE__ */ __name((value = true) => {
+  Registry.silent = !!value;
+}, "silent");
+const registerCompiler = /* @__PURE__ */ __name((compiler) => {
+  if ((0, import_shared.isFn)(compiler)) {
+    Registry.compile = compiler;
+  }
+}, "registerCompiler");
+const shallowCompile = /* @__PURE__ */ __name((source, scope) => {
+  if ((0, import_shared.isStr)(source)) {
+    const matched = source.match(ExpRE);
+    if (!matched) return source;
+    return Registry.compile(matched[1], scope);
+  }
+  return source;
+}, "shallowCompile");
+const compile = /* @__PURE__ */ __name((source, scope) => {
+  const seenObjects = [];
+  const compile2 = /* @__PURE__ */ __name((source2) => {
+    if ((0, import_shared.isStr)(source2)) {
+      return shallowCompile(source2, scope);
+    } else if ((0, import_shared.isArr)(source2)) {
+      return source2.map((value) => compile2(value));
+    } else if ((0, import_shared.isPlainObj)(source2)) {
+      if ((0, import_shared2.isNoNeedCompileObject)(source2)) return source2;
+      const seenIndex = seenObjects.indexOf(source2);
+      if (seenIndex > -1) {
+        return source2;
+      }
+      const addIndex = seenObjects.length;
+      seenObjects.push(source2);
+      const results = (0, import_shared.reduce)(
+        source2,
+        (buf, value, key) => {
+          buf[key] = compile2(value);
+          return buf;
+        },
+        {}
+      );
+      seenObjects.splice(addIndex, 1);
+      return results;
+    }
+    return source2;
+  }, "compile");
+  return compile2(source);
+}, "compile");
+const patchCompile = /* @__PURE__ */ __name((targetState, sourceState, scope) => {
+  (0, import_shared2.traverse)(sourceState, (value, pattern) => {
+    const compiled = compile(value, scope);
+    if (compiled === void 0) return;
+    const path = import_shared.FormPath.parse(pattern);
+    const key = path.segments[0];
+    if (import_shared2.hasOwnProperty.call(targetState, key)) {
+      (0, import_reactive.untracked)(() => import_shared.FormPath.setIn(targetState, path, compiled));
+    }
+  });
+}, "patchCompile");
+const patchSchemaCompile = /* @__PURE__ */ __name((targetState, sourceSchema, scope, demand = false) => {
+  (0, import_shared2.traverseSchema)(sourceSchema, (value, path, omitCompile) => {
+    let compiled = value;
+    let collected = (0, import_reactive.hasCollected)(() => {
+      if (!omitCompile) {
+        compiled = compile(value, scope);
+      }
+    });
+    if (compiled === void 0) return;
+    if (demand) {
+      if (collected || !targetState.initialized) {
+        (0, import_shared2.patchStateFormSchema)(targetState, path, compiled);
+      }
+    } else {
+      (0, import_shared2.patchStateFormSchema)(targetState, path, compiled);
+    }
+  });
+}, "patchSchemaCompile");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile,
+  patchCompile,
+  patchSchemaCompile,
+  registerCompiler,
+  shallowCompile,
+  silent
+});

package/lib/json-schema/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema';
+export * from './types';

package/lib/json-schema/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 json_schema_exports = {};
+module.exports = __toCommonJS(json_schema_exports);
+__reExport(json_schema_exports, require("./schema"), module.exports);
+__reExport(json_schema_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./schema"),
+  ...require("./types")
+});

package/lib/json-schema/patches.d.ts

@@ -0,0 +1,5 @@
+import { SchemaPatch } from './types';
+export declare const reducePatches: (schema: any) => any;
+export declare const registerPatches: (...args: SchemaPatch[]) => void;
+export declare const registerPolyfills: (version: string, patch: SchemaPatch) => void;
+export declare const enablePolyfills: (versions?: string[]) => void;

package/lib/json-schema/patches.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var patches_exports = {};
+__export(patches_exports, {
+  enablePolyfills: () => enablePolyfills,
+  reducePatches: () => reducePatches,
+  registerPatches: () => registerPatches,
+  registerPolyfills: () => registerPolyfills
+});
+module.exports = __toCommonJS(patches_exports);
+var import_shared = require("../shared");
+const patches = [];
+const polyfills = {};
+const reducePatches = /* @__PURE__ */ __name((schema) => {
+  return patches.reduce(
+    (buf, patch) => {
+      return patch(buf);
+    },
+    { ...schema }
+  );
+}, "reducePatches");
+const registerPatches = /* @__PURE__ */ __name((...args) => {
+  args.forEach((patch) => {
+    if ((0, import_shared.isFn)(patch)) {
+      patches.push(patch);
+    }
+  });
+}, "registerPatches");
+const registerPolyfills = /* @__PURE__ */ __name((version, patch) => {
+  if (version && (0, import_shared.isFn)(patch)) {
+    polyfills[version] = polyfills[version] || [];
+    polyfills[version].push(patch);
+  }
+}, "registerPolyfills");
+const enablePolyfills = /* @__PURE__ */ __name((versions) => {
+  if ((0, import_shared.isArr)(versions)) {
+    versions.forEach((version) => {
+      if ((0, import_shared.isArr)(polyfills[version])) {
+        polyfills[version].forEach((patch) => {
+          registerPatches(patch);
+        });
+      }
+    });
+  }
+}, "enablePolyfills");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enablePolyfills,
+  reducePatches,
+  registerPatches,
+  registerPolyfills
+});

package/lib/json-schema/polyfills/SPECIFICATION_1_0.d.ts

@@ -0,0 +1,2 @@
+export declare const registerVoidComponents: (components: string[]) => void;
+export declare const registerTypeDefaultComponents: (maps: Record<string, string>) => void;