@tachybase/schema 0.23.41 → 0.23.47

package/lib/shared/defaults.js

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var defaults_exports = {};
+__export(defaults_exports, {
+  defaults: () => defaults
+});
+module.exports = __toCommonJS(defaults_exports);
+var import_array = require("./array");
+var import_checkers = require("./checkers");
+var import_isEmpty = require("./isEmpty");
+const isUnNormalObject = /* @__PURE__ */ __name((value) => {
+  if ((value == null ? void 0 : value._owner) && (value == null ? void 0 : value.$$typeof)) {
+    return true;
+  }
+  if ((value == null ? void 0 : value._isAMomentObject) || (value == null ? void 0 : value._isJSONSchemaObject)) {
+    return true;
+  }
+  if ((value == null ? void 0 : value.toJS) || (value == null ? void 0 : value.toJSON)) {
+    return true;
+  }
+}, "isUnNormalObject");
+const isEnumerableObject = /* @__PURE__ */ __name((val) => {
+  if (isUnNormalObject(val)) {
+    return false;
+  }
+  return typeof val === "object";
+}, "isEnumerableObject");
+const defaults = /* @__PURE__ */ __name((defaults_, targets) => {
+  if ((0, import_checkers.getType)(defaults_) !== (0, import_checkers.getType)(targets) || !isEnumerableObject(defaults_) || !isEnumerableObject(targets)) {
+    return !(0, import_isEmpty.isEmpty)(targets) ? targets : defaults_;
+  } else {
+    const results = (0, import_checkers.isArr)(defaults_) ? [] : (0, import_checkers.isPlainObj)(defaults_) ? {} : defaults_;
+    (0, import_array.each)(targets, (value, key) => {
+      results[key] = defaults(defaults_[key], value);
+    });
+    (0, import_array.each)(defaults_, (value, key) => {
+      if (!(0, import_isEmpty.isValid)(results[key])) {
+        results[key] = value;
+      }
+    });
+    return results;
+  }
+}, "defaults");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaults
+});

package/lib/shared/deprecate.d.ts

@@ -0,0 +1 @@
+export declare function deprecate<P1 = any, P2 = any, P3 = any, P4 = any, P5 = any>(method: any, message?: string, help?: string): (p1?: P1, p2?: P2, p3?: P3, p4?: P4, p5?: P5) => any;

package/lib/shared/deprecate.js

@@ -0,0 +1,42 @@
+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 deprecate_exports = {};
+__export(deprecate_exports, {
+  deprecate: () => deprecate
+});
+module.exports = __toCommonJS(deprecate_exports);
+var import_checkers = require("./checkers");
+const caches = {};
+function deprecate(method, message, help) {
+  if ((0, import_checkers.isFn)(method)) {
+    return function(p1, p2, p3, p4, p5) {
+      deprecate(message, help);
+      return method.apply(this, arguments);
+    };
+  }
+  if ((0, import_checkers.isStr)(method) && !caches[method]) {
+    caches[method] = true;
+    console.warn(new Error(`${method} has been deprecated. Do not continue to use this api.${message || ""}`));
+  }
+}
+__name(deprecate, "deprecate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deprecate
+});

package/lib/shared/global.d.ts

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

package/lib/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/shared/index.d.ts

@@ -0,0 +1,16 @@
+export * from './array';
+export * from './compare';
+export * from './checkers';
+export * from './clone';
+export * from './isEmpty';
+export * from './case';
+export * from './string';
+export * from './global';
+export * from './path';
+export * from './deprecate';
+export * from './subscribable';
+export * from './middleware';
+export * from './merge';
+export * from './instanceof';
+export * from './defaults';
+export * from './uid';

package/lib/shared/index.js

@@ -0,0 +1,51 @@
+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("./array"), module.exports);
+__reExport(shared_exports, require("./compare"), module.exports);
+__reExport(shared_exports, require("./checkers"), module.exports);
+__reExport(shared_exports, require("./clone"), module.exports);
+__reExport(shared_exports, require("./isEmpty"), module.exports);
+__reExport(shared_exports, require("./case"), module.exports);
+__reExport(shared_exports, require("./string"), module.exports);
+__reExport(shared_exports, require("./global"), module.exports);
+__reExport(shared_exports, require("./path"), module.exports);
+__reExport(shared_exports, require("./deprecate"), module.exports);
+__reExport(shared_exports, require("./subscribable"), module.exports);
+__reExport(shared_exports, require("./middleware"), module.exports);
+__reExport(shared_exports, require("./merge"), module.exports);
+__reExport(shared_exports, require("./instanceof"), module.exports);
+__reExport(shared_exports, require("./defaults"), module.exports);
+__reExport(shared_exports, require("./uid"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./array"),
+  ...require("./compare"),
+  ...require("./checkers"),
+  ...require("./clone"),
+  ...require("./isEmpty"),
+  ...require("./case"),
+  ...require("./string"),
+  ...require("./global"),
+  ...require("./path"),
+  ...require("./deprecate"),
+  ...require("./subscribable"),
+  ...require("./middleware"),
+  ...require("./merge"),
+  ...require("./instanceof"),
+  ...require("./defaults"),
+  ...require("./uid")
+});

package/lib/shared/instanceof.d.ts

@@ -0,0 +1 @@
+export declare const instOf: (value: any, cls: any) => boolean;

package/lib/shared/instanceof.js

@@ -0,0 +1,36 @@
+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 instanceof_exports = {};
+__export(instanceof_exports, {
+  instOf: () => instOf
+});
+module.exports = __toCommonJS(instanceof_exports);
+var import_checkers = require("./checkers");
+var import_global = require("./global");
+const instOf = /* @__PURE__ */ __name((value, cls) => {
+  if ((0, import_checkers.isFn)(cls)) return value instanceof cls;
+  if ((0, import_checkers.isStr)(cls)) {
+    return import_global.globalThisPolyfill[cls] ? value instanceof import_global.globalThisPolyfill[cls] : false;
+  }
+  return false;
+}, "instOf");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  instOf
+});

package/lib/shared/isEmpty.d.ts

@@ -0,0 +1,3 @@
+export declare const isUndef: (val: any) => boolean;
+export declare const isValid: (val: any) => boolean;
+export declare function isEmpty(val: any, strict?: boolean): boolean;

package/lib/shared/isEmpty.js

@@ -0,0 +1,94 @@
+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 isEmpty_exports = {};
+__export(isEmpty_exports, {
+  isEmpty: () => isEmpty,
+  isUndef: () => isUndef,
+  isValid: () => isValid
+});
+module.exports = __toCommonJS(isEmpty_exports);
+var import_instanceof = require("./instanceof");
+const has = Object.prototype.hasOwnProperty;
+const toString = Object.prototype.toString;
+const isUndef = /* @__PURE__ */ __name((val) => val === void 0, "isUndef");
+const isValid = /* @__PURE__ */ __name((val) => val !== void 0 && val !== null, "isValid");
+function isEmpty(val, strict = false) {
+  if (val == null) {
+    return true;
+  }
+  if (typeof val === "boolean") {
+    return false;
+  }
+  if (typeof val === "number") {
+    return false;
+  }
+  if (typeof val === "string") {
+    return val.length === 0;
+  }
+  if (typeof val === "function") {
+    return val.length === 0;
+  }
+  if (Array.isArray(val)) {
+    if (val.length === 0) {
+      return true;
+    }
+    for (let i = 0; i < val.length; i++) {
+      if (strict) {
+        if (val[i] !== void 0 && val[i] !== null) {
+          return false;
+        }
+      } else {
+        if (val[i] !== void 0 && val[i] !== null && val[i] !== "" && val[i] !== 0) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  if ((0, import_instanceof.instOf)(val, "Error")) {
+    return val.message === "";
+  }
+  if (val.toString === toString) {
+    switch (val.toString()) {
+      // Maps, Sets, Files and Errors...
+      case "[object File]":
+      case "[object Map]":
+      case "[object Set]": {
+        return val.size === 0;
+      }
+      // Plain objects...
+      case "[object Object]": {
+        for (const key in val) {
+          if (has.call(val, key)) {
+            return false;
+          }
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+__name(isEmpty, "isEmpty");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isEmpty,
+  isUndef,
+  isValid
+});

package/lib/shared/merge.d.ts

@@ -0,0 +1,12 @@
+interface Options {
+    arrayMerge?(target: any[], source: any[], options?: Options): any[];
+    clone?: boolean;
+    assign?: boolean;
+    customMerge?: (key: string, options?: Options) => ((x: any, y: any) => any) | undefined;
+    isMergeableObject?(value: object): boolean;
+    cloneUnlessOtherwiseSpecified?: (value: any, options: Options) => any;
+}
+declare function deepmerge(target: any, source: any, options?: Options): any;
+export declare const lazyMerge: <T extends object | Function>(target: T, ...args: T[]) => any;
+export declare const merge: typeof deepmerge;
+export {};

package/lib/shared/merge.js

@@ -0,0 +1,214 @@
+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 merge_exports = {};
+__export(merge_exports, {
+  lazyMerge: () => lazyMerge,
+  merge: () => merge
+});
+module.exports = __toCommonJS(merge_exports);
+var import_checkers = require("./checkers");
+var import_isEmpty = require("./isEmpty");
+function defaultIsMergeableObject(value) {
+  return isNonNullObject(value) && !isSpecial(value);
+}
+__name(defaultIsMergeableObject, "defaultIsMergeableObject");
+function isNonNullObject(value) {
+  return Boolean(value) && typeof value === "object";
+}
+__name(isNonNullObject, "isNonNullObject");
+function isSpecial(value) {
+  if ("$$typeof" in value && "_owner" in value) {
+    return true;
+  }
+  if (value._isAMomentObject) {
+    return true;
+  }
+  if (value._isJSONSchemaObject) {
+    return true;
+  }
+  if ((0, import_checkers.isFn)(value.toJS)) {
+    return true;
+  }
+  if ((0, import_checkers.isFn)(value.toJSON)) {
+    return true;
+  }
+  return !(0, import_checkers.isPlainObj)(value);
+}
+__name(isSpecial, "isSpecial");
+function emptyTarget(val) {
+  return Array.isArray(val) ? [] : {};
+}
+__name(emptyTarget, "emptyTarget");
+function cloneUnlessOtherwiseSpecified(value, options) {
+  var _a;
+  if (options.clone !== false && ((_a = options.isMergeableObject) == null ? void 0 : _a.call(options, value))) {
+    return deepmerge(emptyTarget(value), value, options);
+  }
+  return value;
+}
+__name(cloneUnlessOtherwiseSpecified, "cloneUnlessOtherwiseSpecified");
+function defaultArrayMerge(target, source, options) {
+  return target.concat(source).map(function(element) {
+    return cloneUnlessOtherwiseSpecified(element, options);
+  });
+}
+__name(defaultArrayMerge, "defaultArrayMerge");
+function getMergeFunction(key, options) {
+  if (!options.customMerge) {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(key);
+  return typeof customMerge === "function" ? customMerge : deepmerge;
+}
+__name(getMergeFunction, "getMergeFunction");
+function getEnumerableOwnPropertySymbols(target) {
+  return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+    return target.propertyIsEnumerable(symbol);
+  }) : [];
+}
+__name(getEnumerableOwnPropertySymbols, "getEnumerableOwnPropertySymbols");
+function getKeys(target) {
+  if (!(0, import_isEmpty.isValid)(target)) return [];
+  return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+}
+__name(getKeys, "getKeys");
+function propertyIsOnObject(object, property) {
+  try {
+    return property in object;
+  } catch (_) {
+    return false;
+  }
+}
+__name(propertyIsOnObject, "propertyIsOnObject");
+function propertyIsUnsafe(target, key) {
+  return propertyIsOnObject(target, key) && // Properties are safe to merge if they don't exist in the target yet,
+  !(Object.hasOwnProperty.call(target, key) && // unsafe if they exist up the prototype chain,
+  Object.propertyIsEnumerable.call(target, key));
+}
+__name(propertyIsUnsafe, "propertyIsUnsafe");
+function mergeObject(target, source, options) {
+  const destination = options.assign ? target || {} : {};
+  if (!options.isMergeableObject(target)) return target;
+  if (!options.assign) {
+    getKeys(target).forEach(function(key) {
+      destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+    });
+  }
+  getKeys(source).forEach(function(key) {
+    if (propertyIsUnsafe(target, key)) {
+      return;
+    }
+    if ((0, import_isEmpty.isEmpty)(target[key])) {
+      destination[key] = source[key];
+    } else if (propertyIsOnObject(target, key) && // @ts-ignore
+    options.isMergeableObject(source[key])) {
+      destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+    } else {
+      destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+    }
+  });
+  return destination;
+}
+__name(mergeObject, "mergeObject");
+function deepmerge(target, source, options) {
+  options = options || {};
+  options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+  options.isMergeableObject = options.isMergeableObject || defaultIsMergeableObject;
+  options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+  const sourceIsArray = Array.isArray(source);
+  const targetIsArray = Array.isArray(target);
+  const sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(source, options);
+  } else if (sourceIsArray) {
+    return options.arrayMerge(target, source, options);
+  } else {
+    return mergeObject(target, source, options);
+  }
+}
+__name(deepmerge, "deepmerge");
+const lazyMerge = /* @__PURE__ */ __name((target, ...args) => {
+  const _lazyMerge = /* @__PURE__ */ __name((target2, source) => {
+    if (!(0, import_isEmpty.isValid)(source)) return target2;
+    if (!(0, import_isEmpty.isValid)(target2)) return source;
+    const isTargetObject = typeof target2 === "object";
+    const isSourceObject = typeof source === "object";
+    const isTargetFn = typeof target2 === "function";
+    const isSourceFn = typeof source === "function";
+    if (!isTargetObject && !isTargetFn) return source;
+    if (!isSourceObject && !isSourceFn) return target2;
+    const getTarget = /* @__PURE__ */ __name(() => isTargetFn ? target2() : target2, "getTarget");
+    const getSource = /* @__PURE__ */ __name(() => isSourceFn ? source() : source, "getSource");
+    const set = /* @__PURE__ */ __name((_, key, value) => {
+      const source2 = getSource();
+      const target3 = getTarget();
+      if (key in source2) {
+        source2[key] = value;
+      } else if (key in target3) {
+        target3[key] = value;
+      } else {
+        source2[key] = value;
+      }
+      return true;
+    }, "set");
+    const get = /* @__PURE__ */ __name((_, key) => {
+      const source2 = getSource();
+      if (key in source2) {
+        return source2[key];
+      }
+      return getTarget()[key];
+    }, "get");
+    const ownKeys = /* @__PURE__ */ __name(() => {
+      const source2 = getSource();
+      const target3 = getTarget();
+      const keys = Object.keys(target3);
+      for (const key in source2) {
+        if (!(key in target3)) {
+          keys.push(key);
+        }
+      }
+      return keys;
+    }, "ownKeys");
+    const getOwnPropertyDescriptor = /* @__PURE__ */ __name((_, key) => ({
+      value: get(_, key),
+      enumerable: true,
+      configurable: true
+    }), "getOwnPropertyDescriptor");
+    const has = /* @__PURE__ */ __name((_, key) => {
+      if (key in getSource() || key in getTarget()) return true;
+      return false;
+    }, "has");
+    const getPrototypeOf = /* @__PURE__ */ __name(() => Object.getPrototypeOf({}), "getPrototypeOf");
+    return new Proxy(/* @__PURE__ */ Object.create(null), {
+      set,
+      get,
+      ownKeys,
+      getPrototypeOf,
+      getOwnPropertyDescriptor,
+      has
+    });
+  }, "_lazyMerge");
+  return args.reduce((buf, arg) => _lazyMerge(buf, arg), target);
+}, "lazyMerge");
+const merge = deepmerge;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lazyMerge,
+  merge
+});

package/lib/shared/middleware.d.ts

@@ -0,0 +1,4 @@
+export interface IMiddleware<Payload = any, Result = any> {
+    (payload: Payload, next: (payload?: Payload) => Result): Result;
+}
+export declare const applyMiddleware: (payload: any, fns?: IMiddleware[]) => Promise<unknown>;

package/lib/shared/middleware.js

@@ -0,0 +1,41 @@
+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 middleware_exports = {};
+__export(middleware_exports, {
+  applyMiddleware: () => applyMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+const applyMiddleware = /* @__PURE__ */ __name((payload, fns = []) => {
+  const compose = /* @__PURE__ */ __name((payload2, fns2) => {
+    const prevPayload = payload2;
+    return Promise.resolve(fns2[0](payload2, (payload3) => compose(payload3 ?? prevPayload, fns2.slice(1))));
+  }, "compose");
+  return new Promise((resolve, reject) => {
+    compose(
+      payload,
+      fns.concat((payload2) => {
+        resolve(payload2);
+      })
+    ).catch(reject);
+  });
+}, "applyMiddleware");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyMiddleware
+});

package/lib/shared/path.d.ts

@@ -0,0 +1,3 @@
+import { Path as FormPath, Pattern as FormPathPattern } from '../path';
+export { FormPath };
+export type { FormPathPattern };

package/lib/shared/path.js

@@ -0,0 +1,27 @@
+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 path_exports = {};
+__export(path_exports, {
+  FormPath: () => import_path.Path
+});
+module.exports = __toCommonJS(path_exports);
+var import_path = require("../path");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormPath
+});