@farris/devkit-vue/devkit-vue.esm.js

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};
import { ref, unref, computed, effectScope, inject, triggerRef, reactive, toRef, getCurrentInstance, provide, onUnmounted } from "vue";
import axios from "axios";
const Type = Function;
function isType(v) {
  return typeof v === "function";
}
var InjectFlags = /* @__PURE__ */ ((InjectFlags2) => {
  InjectFlags2[InjectFlags2["Default"] = 0] = "Default";
  InjectFlags2[InjectFlags2["Self"] = 1] = "Self";
  InjectFlags2[InjectFlags2["SkipSelf"] = 2] = "SkipSelf";
  InjectFlags2[InjectFlags2["Optional"] = 4] = "Optional";
  return InjectFlags2;
})(InjectFlags || {});
var OptionFlags = /* @__PURE__ */ ((OptionFlags2) => {
  OptionFlags2[OptionFlags2["Optional"] = 1] = "Optional";
  OptionFlags2[OptionFlags2["CheckSelf"] = 2] = "CheckSelf";
  OptionFlags2[OptionFlags2["CheckParent"] = 4] = "CheckParent";
  OptionFlags2[OptionFlags2["Default"] = 6] = "Default";
  return OptionFlags2;
})(OptionFlags || {});
const EMPTY = [];
const IDENT = function(value) {
  return value;
};
const CIRCULAR = IDENT;
const MULTI_PROVIDER_FN = function() {
  return Array.prototype.slice.call(arguments);
};
const NEW_LINE = /\n/gm;
const NO_NEW_LINE = "ɵ";
const _THROW_IF_NOT_FOUND = {};
const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
function stringify(token) {
  if (typeof token === "string") {
    return token;
  }
  if (Array.isArray(token)) {
    return "[" + token.map(stringify).join(", ") + "]";
  }
  if (token == null) {
    return "" + token;
  }
  if (token.overriddenName) {
    return `${token.overriddenName}`;
  }
  if (token.name) {
    return `${token.name}`;
  }
  const res = token.toString();
  if (res == null) {
    return "" + res;
  }
  const newLineIndex = res.indexOf("\n");
  return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
}
function getClosureSafeProperty(objWithPropertyToExtract) {
  for (const key in objWithPropertyToExtract) {
    if (objWithPropertyToExtract[key] === getClosureSafeProperty) {
      return key;
    }
  }
  throw Error("Could not find renamed property on target object.");
}
function formatError(text, obj, injectorErrorName, source = null) {
  text = text && text.charAt(0) === "\n" && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;
  let context = stringify(obj);
  if (Array.isArray(obj)) {
    context = obj.map(stringify).join(" -> ");
  } else if (typeof obj === "object") {
    const parts = [];
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        const value = obj[key];
        parts.push(
          key + ":" + (typeof value === "string" ? JSON.stringify(value) : stringify(value))
        );
      }
    }
    context = `{${parts.join(", ")}}`;
  }
  return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context}]: ${text.replace(NEW_LINE, "\n  ")}`;
}
function staticError(text, obj) {
  return new Error(formatError(text, obj, "StaticInjectorError"));
}
function ɵɵdefineInjectable(opts) {
  return {
    token: opts.token,
    providedIn: opts.providedIn || null,
    factory: opts.factory,
    value: void 0
  };
}
const NG_PROV_DEF = getClosureSafeProperty({ ɵprov: getClosureSafeProperty });
getClosureSafeProperty({ ɵinj: getClosureSafeProperty });
const NG_INJECTABLE_DEF = getClosureSafeProperty({ ngInjectableDef: getClosureSafeProperty });
function getOwnDefinition(type, def) {
  return def && def.token === type ? def : null;
}
function getInjectableDef(type) {
  return getOwnDefinition(type, type[NG_PROV_DEF]) || getOwnDefinition(type, type[NG_INJECTABLE_DEF]);
}
class InjectionToken {
  constructor(_desc, options) {
    __publicField(this, "ngMetadataName", "InjectionToken");
    __publicField(this, "ɵprov");
    this._desc = _desc;
    this.ɵprov = void 0;
    if (typeof options === "number") {
      this.__NG_ELEMENT_ID__ = options;
    } else if (options !== void 0) {
      this.ɵprov = ɵɵdefineInjectable({
        token: this,
        providedIn: options.providedIn || "root",
        factory: options.factory
      });
    }
  }
  toString() {
    return `InjectionToken ${this._desc}`;
  }
}
function createInjectionToken(token) {
  return new InjectionToken(token);
}
class Injector {
}
class NullInjector {
  get(token, notFoundValue = THROW_IF_NOT_FOUND) {
    if (notFoundValue === THROW_IF_NOT_FOUND) {
      const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
      error.name = "NullInjectorError";
      throw error;
    }
    return notFoundValue;
  }
}
const NULL_INJECTOR = new NullInjector();
const __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
function resolveForwardRef(type) {
  return isForwardRef(type) ? type() : type;
}
function forwardRef(forwardRefFn) {
  forwardRefFn.__forward_ref__ = forwardRef;
  forwardRefFn.toString = function() {
    return stringify(this());
  };
  return forwardRefFn;
}
function isForwardRef(fn) {
  return typeof fn === "function" && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;
}
const INJECTOR = new InjectionToken("INJECTOR", -1);
const USE_VALUE = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });
let _currentInjector = void 0;
function setCurrentInjector(injector) {
  const former = _currentInjector;
  _currentInjector = injector;
  return former;
}
class StaticInjector {
  constructor(providers, parent = NULL_INJECTOR, source = null) {
    __publicField(this, "parent");
    __publicField(this, "source");
    __publicField(this, "scope");
    __publicField(this, "_records");
    parent = parent ? parent : NULL_INJECTOR;
    this.parent = parent;
    this.source = source;
    const records = this._records = /* @__PURE__ */ new Map();
    records.set(Injector, { token: Injector, fn: IDENT, deps: EMPTY, value: this, useNew: false });
    records.set(INJECTOR, { token: INJECTOR, fn: IDENT, deps: EMPTY, value: this, useNew: false });
    this.scope = recursivelyProcessProviders(records, providers);
  }
  get(token, notFoundValue, flags = InjectFlags.Default) {
    const records = this._records;
    let record = records.get(token);
    if (record === void 0) {
      const injectableDef = getInjectableDef(token);
      if (injectableDef) {
        const providedIn = injectableDef && injectableDef.providedIn;
        if (providedIn === "any" || providedIn != null && providedIn === this.scope) {
          records.set(
            token,
            record = resolveProvider({ provide: token, useFactory: injectableDef.factory, deps: EMPTY })
          );
        }
      }
      if (record === void 0) {
        records.set(token, null);
      }
    }
    const lastInjector = setCurrentInjector(this);
    try {
      return tryResolveToken(token, record, records, this.parent, notFoundValue, flags);
    } catch (e) {
      throw e;
    } finally {
      setCurrentInjector(lastInjector);
    }
  }
  toString() {
    const tokens = [];
    const records = this._records;
    records.forEach((v, token) => tokens.push(stringify(token)));
    return `StaticInjector[${tokens.join(", ")}]`;
  }
}
function multiProviderMixError(token) {
  return staticError("Cannot mix multi providers and regular providers", token);
}
const INJECTOR_SCOPE = new InjectionToken("Set Injector scope.");
function recursivelyProcessProviders(records, provider) {
  let scope = null;
  if (provider) {
    provider = resolveForwardRef(provider);
    if (Array.isArray(provider)) {
      for (let i = 0; i < provider.length; i++) {
        scope = recursivelyProcessProviders(records, provider[i]) || scope;
      }
    } else if (typeof provider === "function") {
      throw staticError("Function/Class not supported", provider);
    } else if (provider && typeof provider === "object" && provider.provide) {
      let token = resolveForwardRef(provider.provide);
      const resolvedProvider = resolveProvider(provider);
      if (provider.multi === true) {
        let multiProvider = records.get(token);
        if (multiProvider) {
          if (multiProvider.fn !== MULTI_PROVIDER_FN) {
            throw multiProviderMixError(token);
          }
        } else {
          records.set(token, multiProvider = {
            token: provider.provide,
            deps: [],
            useNew: false,
            fn: MULTI_PROVIDER_FN,
            value: EMPTY
          });
        }
        token = provider;
        multiProvider.deps.push({ token, options: OptionFlags.Default });
      }
      const record = records.get(token);
      if (record && record.fn === MULTI_PROVIDER_FN) {
        throw multiProviderMixError(token);
      }
      if (token === INJECTOR_SCOPE) {
        scope = resolvedProvider.value;
      }
      records.set(token, resolvedProvider);
    } else {
      throw staticError("Unexpected provider", provider);
    }
  }
  return scope;
}
function resolveProvider(provider) {
  const deps = computeDeps(provider);
  let fn = IDENT;
  let value = EMPTY;
  let useNew = false;
  const provide2 = resolveForwardRef(provider.provide);
  if (USE_VALUE in provider) {
    value = provider.useValue;
  } else if (provider.useFactory) {
    fn = provider.useFactory;
  } else if (provider.useExisting)
    ;
  else if (provider.useClass) {
    useNew = true;
    fn = resolveForwardRef(provider.useClass);
  } else if (typeof provide2 === "function") {
    useNew = true;
    fn = provide2;
  } else {
    throw staticError(
      "StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable",
      provider
    );
  }
  return { deps, fn, useNew, value };
}
function computeDeps(provider) {
  let deps = EMPTY;
  const providerDeps = provider.deps;
  if (providerDeps && providerDeps.length) {
    deps = [];
    for (let i = 0; i < providerDeps.length; i++) {
      const options = OptionFlags.Default;
      const token = resolveForwardRef(providerDeps[i]);
      deps.push({ token, options });
    }
  } else if (provider.useExisting) {
    const token = resolveForwardRef(provider.useExisting);
    deps = [{ token, options: OptionFlags.Default }];
  } else if (!providerDeps && !(USE_VALUE in provider)) {
    throw staticError("'deps' required", provider);
  }
  return deps;
}
function tryResolveToken(token, record, records, parent, notFoundValue, flags) {
  try {
    return resolveToken(token, record, records, parent, notFoundValue, flags);
  } catch (e) {
    const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];
    path.unshift(token);
    if (record && record.value === CIRCULAR) {
      record.value = EMPTY;
    }
    throw e;
  }
}
function resolveToken(token, record, records, parent, notFoundValue, flags) {
  let value;
  if (record && !(flags & InjectFlags.SkipSelf)) {
    value = record.value;
    if (value === CIRCULAR) {
      throw Error(NO_NEW_LINE + "Circular dependency");
    } else if (value === EMPTY) {
      record.value = CIRCULAR;
      const useNew = record.useNew;
      const fn = record.fn;
      const depRecords = record.deps;
      let deps = EMPTY;
      if (depRecords.length) {
        deps = [];
        for (let i = 0; i < depRecords.length; i++) {
          const depRecord = depRecords[i];
          const options = depRecord.options;
          const childRecord = options & OptionFlags.CheckSelf ? records.get(depRecord.token) : void 0;
          deps.push(
            tryResolveToken(
              depRecord.token,
              childRecord,
              records,
              !childRecord && !(options & OptionFlags.CheckParent) ? NULL_INJECTOR : parent,
              options & OptionFlags.Optional ? null : THROW_IF_NOT_FOUND,
              InjectFlags.Default
            )
          );
        }
      }
      record.value = value = useNew ? new fn(...deps) : fn.apply(void 0, deps);
    }
  } else if (!(flags & InjectFlags.Self)) {
    value = parent.get(token, notFoundValue, InjectFlags.Default);
  } else if (!(flags & InjectFlags.Optional)) {
    value = NULL_INJECTOR.get(token, notFoundValue);
  } else {
    value = NULL_INJECTOR.get(token, typeof notFoundValue !== "undefined" ? notFoundValue : null);
  }
  return value;
}
function INJECTOR_IMPL__PRE_R3__(providers, parent, name) {
  return new StaticInjector(providers, parent, name);
}
const INJECTOR_IMPL = INJECTOR_IMPL__PRE_R3__;
function createInjector(options, parent) {
  if (Array.isArray(options)) {
    return INJECTOR_IMPL(options, parent, "");
  } else {
    return INJECTOR_IMPL(options.providers, options.parent, options.name || "");
  }
}
const ANNOTATIONS = "__annotations__";
const PROP_METADATA = "__prop__metadata__";
function makeMetaCtor(metaFactory) {
  return function ctor(...args) {
    if (metaFactory) {
      const values = metaFactory(...args);
      for (const propName in values) {
        this[propName] = values[propName];
      }
    }
  };
}
function makeTypeMetadataDecorator(name, props, parentClass, chainFn, typeFn) {
  const metaCtor = makeMetaCtor(props);
  function DecoratorFactory(...args) {
    if (this instanceof DecoratorFactory) {
      metaCtor.call(this, ...args);
      return this;
    }
    const annotationInstance = new DecoratorFactory(...args);
    const typeDecorator = function createTypeDecorator(cls) {
      typeFn && typeFn(cls, ...args);
      const annotations = cls.hasOwnProperty(ANNOTATIONS) ? cls[ANNOTATIONS] : Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
      annotations.push(annotationInstance);
      return cls;
    };
    if (chainFn) {
      chainFn(typeDecorator);
    }
    return typeDecorator;
  }
  if (parentClass) {
    DecoratorFactory.prototype = Object.create(parentClass.prototype);
  }
  DecoratorFactory.prototype.ngMetadataName = name;
  DecoratorFactory.annotationCls = DecoratorFactory;
  return DecoratorFactory;
}
function getAllPropMetas(target) {
  const constructor = target.constructor;
  let allPropMetas = null;
  if (constructor.hasOwnProperty(PROP_METADATA)) {
    allPropMetas = constructor[PROP_METADATA];
  } else {
    allPropMetas = Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];
  }
  return allPropMetas;
}
function getSinglePropMetas(target, propName) {
  const allPropMetas = getAllPropMetas(target);
  if (allPropMetas.hasOwnProperty(propName)) {
    return allPropMetas[propName];
  }
  return [];
}
function makePropMetadataDecorator(name, metaFactory, parentClass) {
  const metaCtor = makeMetaCtor(metaFactory);
  function PropDecoratorFactory(...args) {
    if (this instanceof PropDecoratorFactory) {
      metaCtor.apply(this, args);
      return this;
    }
    const decoratorInstance = new PropDecoratorFactory(...args);
    function PropDecorator(target, propName) {
      const allPropMetas = getAllPropMetas(target);
      allPropMetas[propName] = getSinglePropMetas(target, propName);
      allPropMetas[propName].unshift(decoratorInstance);
    }
    return PropDecorator;
  }
  if (parentClass) {
    PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
  }
  PropDecoratorFactory.prototype.metadataName = name;
  PropDecoratorFactory.annotationClass = PropDecoratorFactory;
  return PropDecoratorFactory;
}
class PropMetadataReader {
  /**
   * 获取所有属性的所有类型元数据
   */
  static getPropsMetas(constructor) {
    const propsMetas = constructor[PROP_METADATA];
    if (!propsMetas) {
      return {};
    }
    return propsMetas;
  }
  /**
   * 获取所有属性某一类型的元数据
   */
  static getPropsMetasByName(constructor, metaName) {
    const propsMetas = this.getPropsMetas(constructor);
    if (!propsMetas) {
      return {};
    }
    const sameNamePropsMetas = {};
    Object.keys(propsMetas).forEach((propName) => {
      const propMetas = propsMetas[propName];
      const targetPropMeta = propMetas.find((propMeta) => {
        return propMeta.metadataName === metaName;
      });
      if (!targetPropMeta) {
        return;
      }
      sameNamePropsMetas[propName] = targetPropMeta;
    });
    return sameNamePropsMetas;
  }
}
class Effect {
  /**
   * 副作用构造器
   * @param effectFunction 副作用方法
   */
  constructor(effectFunction) {
    /**
     * 副作用方法
     */
    __publicField(this, "internalFunction");
    this.effectFunction = effectFunction;
    this.internalFunction = this.effectFunction;
  }
  /**
   * 执行副作用
   * @param change 变更 
   */
  run(change) {
    this.internalFunction(change);
  }
}
class EffectManager {
  /**
   * 构造函数
   */
  constructor() {
    /**
     * 副作用集合
     */
    __publicField(this, "innerEffects", []);
  }
  /**
   * 添加副作用
   */
  addEffect(effect) {
    if (this.innerEffects.indexOf(effect) > -1) {
      return;
    }
    this.innerEffects.push(effect);
  }
  /**
   * 删除副作用
   */
  removeEffect(effect) {
    this.innerEffects = this.innerEffects.filter((internalEffect) => effect !== internalEffect);
  }
  /**
   * 获取全部副作用
   */
  getEffects() {
    return this.innerEffects;
  }
  /**
   * 执行全部副作用
   */
  trigger(change) {
    this.innerEffects.forEach((effect) => {
      effect.run(change);
    });
  }
}
const _Token = class _Token {
  static create(redix) {
    const timestamp = Date.now().valueOf();
    let uuid = 0;
    if (timestamp > _Token.previous) {
      _Token.previous = timestamp;
      uuid = timestamp;
    } else {
      _Token.previous = _Token.previous + 100;
      uuid = _Token.previous;
    }
    return uuid.toString(redix);
  }
};
__publicField(_Token, "previous", 0);
let Token = _Token;
const EXCEPTION_HANDLER_TOKEN = new InjectionToken("@farris/exception_handler_token");
const STATE_PROP_META_NAME = "STATE";
const stateMetaFactory = (meta) => {
  return meta;
};
const State = makePropMetadataDecorator(STATE_PROP_META_NAME, stateMetaFactory);
const GETTER_PROP_META_NAME = "GETTER";
const getterMetaFactory = (meta) => {
  return meta;
};
const Getter = makePropMetadataDecorator(GETTER_PROP_META_NAME, getterMetaFactory);
const ACTION_PROP_META_NAME = "ACTION";
const actionMetaFactory = (meta) => {
  return meta;
};
const Action = makePropMetadataDecorator(ACTION_PROP_META_NAME, actionMetaFactory);
const COMMAND_ACTION_PROP_META_NAME = "COMMAND_ACTION";
const commandActionMetaFactory = (meta) => {
  return meta;
};
const CommandAction = makePropMetadataDecorator(COMMAND_ACTION_PROP_META_NAME, commandActionMetaFactory);
class PropWrapper {
  /**
   * 构造函数
   */
  constructor(viewModel, propName, propMeta, scope) {
    /**
     * 视图模型
     */
    __publicField(this, "viewModel");
    /**
     * 属性名车给你
     */
    __publicField(this, "propName");
    /**
     * 属性元数据
     */
    __publicField(this, "propMeta");
    /**
     * 副作用上下文
     */
    __publicField(this, "scope");
    this.viewModel = viewModel;
    this.propName = propName;
    this.propMeta = propMeta;
    this.scope = scope;
  }
}
class StatePropWrapper extends PropWrapper {
  /**
   * 构造函数
   */
  constructor(viewModel, propName, propMeta, scope) {
    super(viewModel, propName, propMeta, scope);
  }
  /**
   * 包装属性
   * @summary
   * 将状态属性包装为ref，并自动解包
   */
  wrap() {
    const viewModel = this.viewModel;
    const initValue = viewModel[this.propName];
    function createAccessor() {
      const valueRef = ref(initValue);
      const accessor = {
        get() {
          return unref(valueRef);
        },
        set(value) {
          valueRef.value = value;
        }
      };
      return accessor;
    }
    let cachedAccessor = null;
    function getCachedAccessor() {
      if (!cachedAccessor) {
        cachedAccessor = createAccessor();
      }
      return cachedAccessor;
    }
    Object.defineProperty(viewModel, this.propName, {
      enumerable: true,
      configurable: true,
      get() {
        const accessor = getCachedAccessor();
        return accessor.get();
      },
      set(value) {
        const accessor = getCachedAccessor();
        accessor.set(value);
      }
    });
  }
  /**
   * 注销
   */
  dispose() {
  }
}
class GetterPropWrapper extends PropWrapper {
  /**
   * 构造函数
   */
  constructor(viewModel, propName, propMeta, scope) {
    super(viewModel, propName, propMeta, scope);
  }
  /**
   * 包装属性
   * @summary
   * 将get方法包装成计算属性
   */
  wrap() {
    const viewModel = this.viewModel;
    const viewModelPrototype = viewModel.constructor.prototype;
    const getterPropDescriptor = Object.getOwnPropertyDescriptor(viewModelPrototype, this.propName);
    if (!getterPropDescriptor || !getterPropDescriptor.get) {
      return;
    }
    const getter = getterPropDescriptor.get;
    const computedGetter = this.scope.run(() => {
      return computed(() => {
        return getter.call(viewModel);
      });
    });
    Object.defineProperty(viewModel, this.propName, {
      enumerable: true,
      configurable: true,
      get() {
        return computedGetter;
      }
    });
  }
  /**
   * 注销
   */
  dispose() {
  }
}
class ActionPropWrapper extends PropWrapper {
  /**
   * 构造函数
   */
  constructor(viewModel, propName, propMeta, scope) {
    super(viewModel, propName, propMeta, scope);
  }
  /**
   * 包装属性
   * @summary
   * 对原始动作进行包装，跟踪方法的执行过程
   */
  wrap() {
    const viewModel = this.viewModel;
    const viewModelPrototype = viewModel.constructor.prototype;
    const actionPropDescriptor = Object.getOwnPropertyDescriptor(viewModelPrototype, this.propName);
    if (!actionPropDescriptor || !actionPropDescriptor.value) {
      return;
    }
    const action = actionPropDescriptor.value;
    const wrappedAction = this.wrapAction(action);
    Object.defineProperty(viewModel, this.propName, {
      enumerable: true,
      configurable: true,
      get() {
        return wrappedAction;
      }
    });
  }
  /**
   * 包装动作
   */
  wrapAction(action) {
    const viewModel = this.viewModel;
    const wrappedAction = function() {
      const args = Array.from(arguments);
      return action.call(viewModel, ...args);
    };
    return wrappedAction;
  }
  /**
   * 注销
   */
  dispose() {
  }
}
class CommandActionPropWrapper extends ActionPropWrapper {
  /**
   * 构造函数
   */
  constructor(viewModel, propName, propMeta, scope) {
    super(viewModel, propName, propMeta, scope);
  }
  /**
   * 包装属性
   * @summary
   * 对原始动作进行包装，跟踪方法的执行过程
   */
  wrap() {
    const viewModel = this.viewModel;
    const propMeta = this.propMeta;
    const commandAction = function(eventParams) {
      const command = {
        name: propMeta.name,
        params: { ...propMeta.params },
        eventParams: eventParams ? JSON.parse(JSON.stringify(eventParams)) : null
      };
      return viewModel.dispatch(command);
    };
    const wrappedAction = this.wrapAction(commandAction);
    Object.defineProperty(viewModel, this.propName, {
      enumerable: true,
      configurable: true,
      get() {
        return wrappedAction;
      }
    });
  }
  /**
   * 注销
   */
  dispose() {
  }
}
class PropWrapperFactory {
  /**
   * 创建属性包装器
   */
  create(viewModel, propName, propMeta, scope) {
    let wrapper;
    switch (propMeta.metadataName) {
      case STATE_PROP_META_NAME:
        wrapper = new StatePropWrapper(viewModel, propName, propMeta, scope);
        break;
      case GETTER_PROP_META_NAME:
        wrapper = new GetterPropWrapper(viewModel, propName, propMeta, scope);
        break;
      case ACTION_PROP_META_NAME:
        wrapper = new ActionPropWrapper(viewModel, propName, propMeta, scope);
        break;
      case COMMAND_ACTION_PROP_META_NAME:
        wrapper = new CommandActionPropWrapper(viewModel, propName, propMeta, scope);
        break;
      default:
        throw new Error(`No PropWrapper for ${propMeta.metadataName}`);
    }
    return wrapper;
  }
}
const PRIMITIVE_FIELD_META_NAME = "PRIMITIVE_FIELD";
const primitiveFieldMetaFactory = (meta) => {
  return meta;
};
const Field = makePropMetadataDecorator(PRIMITIVE_FIELD_META_NAME, primitiveFieldMetaFactory);
const ENTITY_FIELD_META_NAME = "ENTITY_FIELD";
const entityFieldMetaFactory = (meta) => {
  return meta;
};
const EntityField = makePropMetadataDecorator(ENTITY_FIELD_META_NAME, entityFieldMetaFactory);
const ENTITY_LIST_FIELD_META_NAME = "ENTITY_LIST_FIELD";
const entitylistFieldMetaFactory = (meta) => {
  return meta;
};
const EntityListField = makePropMetadataDecorator(ENTITY_LIST_FIELD_META_NAME, entitylistFieldMetaFactory);
var FieldType = /* @__PURE__ */ ((FieldType2) => {
  FieldType2["Primitive"] = "Primitive";
  FieldType2["Entity"] = "Entity";
  FieldType2["EntityList"] = "EntityArray";
  return FieldType2;
})(FieldType || {});
var EntityPathNodeType = /* @__PURE__ */ ((EntityPathNodeType2) => {
  EntityPathNodeType2["IdValue"] = "IdValue";
  EntityPathNodeType2["PropName"] = "PropName";
  return EntityPathNodeType2;
})(EntityPathNodeType || {});
class EntityPathNode {
  /**
   * 构造函数
   */
  constructor(nodeType, nodeValue) {
    /**
     * 类型
     */
    __publicField(this, "nodeType");
    /**
     * 节点值
     */
    __publicField(this, "nodeValue");
    /**
     * 上一路径节点
     */
    __publicField(this, "prevNode");
    /**
     * 下一路径节点
     */
    __publicField(this, "nextNode");
    this.nodeType = nodeType;
    this.nodeValue = nodeValue;
  }
  /**
   * 获取节点类型
   */
  getNodeType() {
    return this.nodeType;
  }
  /**
   * 获取节点值
   */
  getNodeValue() {
    return this.nodeValue;
  }
  /**
   * 设置节点值
   */
  setNodeValue(nodeValue) {
    this.nodeValue = nodeValue;
  }
  /**
   * 获取上一节点
   */
  getPrevNode() {
    return this.prevNode;
  }
  /**
   * 获取下一节点
   */
  getNextNode() {
    return this.nextNode;
  }
  /**
   * 设置上一节点
   */
  setPrevNode(prevNode) {
    this.prevNode = prevNode;
  }
  /**
   * 设置下一节点
   */
  setNextNode(nextNode) {
    this.nextNode = nextNode;
  }
}
class EntityPath {
  /**
   * 构造函数
   */
  constructor() {
    /**
     * 路径节点集合
     */
    __publicField(this, "nodes");
    this.nodes = [];
  }
  /**
   * 获取路径节点
   */
  getNodes() {
    return this.nodes;
  }
  /**
   * 获取第一个节点
   */
  getFirstNode() {
    return this.nodes[0];
  }
  /**
   * 获取最后一个节点
   */
  getLastNode() {
    return this.nodes[this.nodes.length - 1];
  }
  /**
   * 获取父实体路径
   */
  getParentEntityPath() {
    const parentEntityPath = new EntityPath();
    const parentPathNodes = this.nodes.concat([]);
    parentPathNodes.pop();
    parentPathNodes.forEach((parentPathNode) => {
      parentEntityPath.appendNode(parentPathNode);
    });
    return parentEntityPath;
  }
  /**
   * 添加节点
   */
  appendNode(node) {
    const prevNode = this.nodes.length === 0 ? null : this.nodes[0];
    if (prevNode) {
      prevNode.setNextNode(node);
    }
    node.setPrevNode(prevNode);
    this.nodes.push(node);
  }
  /**
   * 是否和当前路径相等
   */
  isSame(entityPath) {
    const targetNodes = entityPath.getNodes();
    if (this.nodes.length !== targetNodes.length) {
      return false;
    }
    const isDifferent = this.nodes.some((node, index) => {
      const targetNode = targetNodes[index];
      const isDifferentType = node.getNodeType() !== targetNode.getNodeType();
      const isDifferentValue = node.getNodeValue() !== targetNode.getNodeValue();
      if (isDifferentType || isDifferentValue) {
        return true;
      }
    });
    return !isDifferent;
  }
  /**
   * 是否为当前路径的祖先路径
   */
  isAncestor(ancestorPath) {
    const ancestorNodes = ancestorPath.getNodes();
    const descendantNodes = this.nodes;
    if (ancestorNodes.length >= descendantNodes.length) {
      return false;
    }
    const isDifferent = ancestorNodes.some((ancestorNode, index) => {
      const descendantNode = descendantNodes[index];
      const isDifferentType = ancestorNode.getNodeValue() !== descendantNode.getNodeType();
      const isDifferentValue = ancestorNode.getNodeValue() !== descendantNode.getNodeValue();
      if (isDifferentType || isDifferentValue) {
        return true;
      }
    });
    return !isDifferent;
  }
  /**
   * 是否为当前路径的父路径
   */
  isParent(parentPath) {
    const ancestorNodes = parentPath.getNodes();
    const descendantNodes = this.nodes;
    if (ancestorNodes.length !== descendantNodes.length - 1) {
      return false;
    }
    return this.isAncestor(parentPath);
  }
  /**
   * 克隆路径
   */
  clone() {
    const clonedEntityPath = new EntityPath();
    this.nodes.forEach((node) => {
      const type = node.getNodeType();
      const value = node.getNodeValue();
      const clonedNode = new EntityPathNode(type, value);
      clonedEntityPath.appendNode(clonedNode);
    });
    return clonedEntityPath;
  }
  /**
   * 转换为短路径
   * @returns 
   */
  toShortPath() {
    return "/" + this.nodes.filter((node) => node.getNodeType() === EntityPathNodeType.PropName).join("/");
  }
}
class EntityPathBuilder {
  /**
   * 构造函数
   */
  constructor(entityState) {
    /**
     * 实体状态
     */
    __publicField(this, "entityState");
    this.entityState = entityState;
  }
  /**
   * 构造实体路径
   */
  build(path, isEntityListPath = false) {
    if (path instanceof EntityPath) {
      return path;
    }
    this.checkPath(path);
    const entityList = this.entityState.getEntityList();
    const pathArray = this.convertToPathArray(path);
    const longPathArray = this.convertToLongPath(pathArray, entityList, isEntityListPath);
    const entityPath = this.buildEntityPath(longPathArray);
    return entityPath;
  }
  /**
   * 根据长路径数组构造实体路径对象
   */
  buildEntityPath(longPathArray) {
    const entityPath = new EntityPath();
    longPathArray.forEach((pathItem) => {
      const isIdPathItem = this.isIdPathItem(pathItem);
      const nodeType = isIdPathItem ? EntityPathNodeType.IdValue : EntityPathNodeType.PropName;
      let nodeValue;
      if (isIdPathItem) {
        nodeValue = pathItem.slice(1).slice(0, -1);
      } else {
        nodeValue = pathItem;
      }
      const pathNode = new EntityPathNode(nodeType, nodeValue);
      entityPath.appendNode(pathNode);
    });
    return entityPath;
  }
  /**
   * 转换为长路径
   * 短路径：/childs/grands/assoInfo/name
   * 长路径：/[id]/childs/[childId]/assoInfo/name
   */
  convertToLongPath(pathArray, entityList, isEntityListPath = false) {
    if (this.isShortPath(pathArray) === false) {
      return pathArray;
    }
    const pathArrayLen = pathArray.length;
    const longPathArray = [];
    if (isEntityListPath && pathArray.length === 0) {
      return longPathArray;
    }
    let currentEntity = entityList.getCurrentEntity();
    const currentId = currentEntity.idValue;
    longPathArray.push(`[${currentId}]`);
    pathArray.forEach((pathItem, pathIndex) => {
      const entitySchema = currentEntity.getSchema();
      const fieldSchema = entitySchema.getFieldSchemaByName(pathItem);
      if (!fieldSchema) {
        throw new Error(`${pathItem} not exist`);
      }
      if (fieldSchema.type === FieldType.EntityList) {
        const childEntityList = currentEntity[pathItem];
        const currentChildEntity = childEntityList.getCurrentEntity();
        longPathArray.push(pathItem);
        if (isEntityListPath && pathIndex === pathArrayLen - 1) {
          return;
        }
        longPathArray.push(`[${currentChildEntity.idValue}]`);
        currentEntity = currentChildEntity;
      } else if (fieldSchema.type === FieldType.Entity) {
        longPathArray.push(pathItem);
        currentEntity = currentEntity[pathItem];
      } else {
        longPathArray.push(pathItem);
      }
    });
    return longPathArray;
  }
  /**
   * 转换为路径数据
   */
  convertToPathArray(path) {
    if (Array.isArray(path)) {
      return path;
    }
    const pathArray = path.split("/").filter((pathItem) => {
      return pathItem;
    });
    return pathArray;
  }
  /**
   * 检查路径是否合法
   */
  checkPath(path) {
    if (!path) {
      throw new Error("path can not be empty");
    }
    if (Array.isArray(path) === true) {
      return;
    }
    if (typeof path !== "string") {
      throw new Error("path must be an string or array");
    }
    if (path.startsWith("/") === false) {
      throw new Error("path must be starts with /");
    }
  }
  /**
   * 检查是否为长路径
   */
  isShortPath(pathArray) {
    const firstPathItem = pathArray[0];
    if (firstPathItem && firstPathItem.startsWith("[")) {
      return false;
    }
    return true;
  }
  /**
   * 检查是否为ID路径片段
   */
  isIdPathItem(pathItem) {
    return pathItem.startsWith("[");
  }
}
class EntitySchema {
  /**
   * 构造函数
   */
  constructor() {
    /**
     * 字段描述集合
     */
    __publicField(this, "fieldSchemaMap");
    /**
     * 主键值
     */
    __publicField(this, "idKey");
    this.fieldSchemaMap = /* @__PURE__ */ new Map();
  }
  /**
   * 获取全部字段描述
   */
  getFieldSchemas() {
    const fieldSchemas = Array.from(this.fieldSchemaMap.values());
    return fieldSchemas;
  }
  /**
   * 根据字段Type获取字段描述
   */
  getFieldSchemasByType(type) {
    const fieldSchemas = this.getFieldSchemas();
    const targetFieldSchemas = fieldSchemas.filter((fieldSchema) => {
      return fieldSchema.type === type;
    });
    return targetFieldSchemas;
  }
  /**
   * 根据字段Name获取字段描述
   */
  getFieldSchemaByName(name) {
    if (!this.fieldSchemaMap.has(name)) {
      return;
    }
    const targetFieldSchema = this.fieldSchemaMap.get(name);
    return targetFieldSchema;
  }
  /**
   * 根据字段Path获取字段描述
   */
  getFieldSchemaByPath(entityPath) {
    const entityPathNodes = entityPath.getNodes();
    let currentEntitySchema = this;
    let currentFieldSchema;
    entityPathNodes.forEach((entityPathNode) => {
      const pathNodeType = entityPathNode.getNodeType();
      const pathNodeValue = entityPathNode.getNodeValue();
      if (pathNodeType === EntityPathNodeType.IdValue) {
        return;
      }
      currentFieldSchema = currentEntitySchema.getFieldSchemaByName(pathNodeValue);
      if (currentFieldSchema.type === FieldType.Entity) {
        currentEntitySchema = currentFieldSchema.entitySchema;
      } else if (currentFieldSchema.type === FieldType.EntityList) {
        currentEntitySchema = currentFieldSchema.entitySchema;
      }
    });
    return currentFieldSchema;
  }
  /**
   * 添加字段信息
   */
  addFieldSchema(fieldSchema) {
    this.fieldSchemaMap.set(fieldSchema.name, fieldSchema);
  }
  /**
   * 设置主键字段
   */
  setIdKey(primaryKey) {
    this.idKey = primaryKey;
  }
  /**
   * 获取主键字段
   */
  getIdKey() {
    return this.idKey;
  }
}
class EntitySchemaCreator {
  /**
   * 构造函数
   */
  constructor(entityType) {
    /**
     * 实体类型
     */
    __publicField(this, "entityType");
    /**
     * 实体描述
     */
    __publicField(this, "entitySchema");
    this.entityType = entityType;
    this.entitySchema = new EntitySchema();
  }
  /**
   * 创建实体描述
   */
  create() {
    this.addFieldSchemas();
    return this.entitySchema;
  }
  /**
   * 添加实体
   */
  addFieldSchemas() {
    this.addPrimitiveFieldSchemas();
    this.addEntityFieldSchemas();
    this.addEntityListFieldSchemas();
  }
  /**
   * 添加简单字段描述
   */
  addPrimitiveFieldSchemas() {
    const fieldMetas = PropMetadataReader.getPropsMetasByName(this.entityType, PRIMITIVE_FIELD_META_NAME);
    Object.keys(fieldMetas).map((propName) => {
      const fieldMeta = fieldMetas[propName];
      const fieldSchema = {
        type: FieldType.Primitive,
        name: propName
      };
      this.entitySchema.addFieldSchema(fieldSchema);
      if (fieldMeta.primary === true) {
        this.entitySchema.setIdKey(propName);
      }
    });
  }
  /**
   * 添加实体字段描述
   */
  addEntityFieldSchemas() {
    const fieldMetas = PropMetadataReader.getPropsMetasByName(this.entityType, ENTITY_FIELD_META_NAME);
    Object.keys(fieldMetas).map((propName) => {
      const fieldMeta = fieldMetas[propName];
      const fieldSchema = {
        type: FieldType.Entity,
        name: propName,
        entitySchema: createEntitySchema(fieldMeta.entityType)
      };
      this.entitySchema.addFieldSchema(fieldSchema);
    });
  }
  /**
   * 添加实体列表字段描述
   */
  addEntityListFieldSchemas() {
    const fieldMetas = PropMetadataReader.getPropsMetasByName(this.entityType, ENTITY_LIST_FIELD_META_NAME);
    Object.keys(fieldMetas).map((propName) => {
      const fieldMeta = fieldMetas[propName];
      const fieldSchema = {
        type: FieldType.EntityList,
        name: propName,
        entitySchema: createEntitySchema(fieldMeta.entityType)
      };
      this.entitySchema.addFieldSchema(fieldSchema);
    });
  }
}
function createEntitySchema(entityType) {
  const schemaCreator = new EntitySchemaCreator(entityType);
  const schema = schemaCreator.create();
  return schema;
}
class EntityNode {
  constructor() {
    /**
     * 父节点
     */
    __publicField(this, "parentEntityNode");
  }
  /**
   * 设置父实体节点
   */
  setParentEntityNode(parentEntityNode) {
    this.parentEntityNode = parentEntityNode;
  }
  /**
   * 获取父实体节点
   */
  getParentEntityNode() {
    return this.parentEntityNode;
  }
}
function createEntity(entityType, entityData) {
  if (!entityType) {
    throw new Error(`The entityType parameter can't be empty`);
  }
  if (!entityData) {
    throw new Error(`The entityData parameter should be an array`);
  }
  const entitySchema = createEntitySchema(entityType);
  const entity = createEntityBySchema(entitySchema, entityData);
  return entity;
}
function createEntityBySchema(entitySchema, entityData) {
  if (!entitySchema) {
    throw new Error(`The entitySchema parameter can't be empty`);
  }
  if (!entityData) {
    throw new Error(`The entityData parameter should be an array`);
  }
  const entity = new Entity(entitySchema);
  entity.loadData(entityData);
  return entity;
}
function createEntities(entityType, entityDatas) {
  if (!entityType) {
    throw new Error(`The entityType parameter can't be empty`);
  }
  if (!Array.isArray(entityDatas)) {
    throw new Error(`The entityDatas parameter should be an array`);
  }
  const entitySchema = createEntitySchema(entityType);
  const entities = createEntitiesBySchema(entitySchema, entityDatas);
  return entities;
}
function createEntitiesBySchema(entitySchema, entityDatas) {
  if (!entitySchema) {
    throw new Error(`The entitySchema parameter can't be empty`);
  }
  if (!Array.isArray(entityDatas)) {
    throw new Error(`The entityDatas parameter should be an array`);
  }
  const entities = entityDatas.map((entityData) => {
    const entity = createEntityBySchema(entitySchema, entityData);
    return entity;
  });
  return entities;
}
class EntityList extends EntityNode {
  /**
   * 构造函数
   */
  constructor(entitySchema) {
    super();
    /**
     * 实体描述
     */
    __publicField(this, "entitySchema");
    /**
     * 实体集合
     */
    __publicField(this, "entities");
    /**
     * 当前实体ID
     */
    __publicField(this, "currentId");
    this.entitySchema = entitySchema;
    this.entities = [];
  }
  /**
   * 加载数据
   */
  loadData(entityDatas) {
    if (!Array.isArray(entityDatas)) {
      throw new Error("The entityDatas parameter should be an array");
    }
    const entities = createEntitiesBySchema(this.entitySchema, entityDatas);
    this.loadEntities(entities);
  }
  /**
   * 加载实体
   */
  loadEntities(entities) {
    this.entities = [];
    entities.forEach((entity) => {
      this.appendEntity(entity);
    });
    if (entities.length === 0) {
      this.currentId = null;
    } else {
      const firstEntity = this.entities[0];
      this.setCurrentId(firstEntity.idValue);
    }
  }
  /**
   * 批量追加实体
   */
  appendEntities(entities) {
    if (Array.isArray(entities) !== true) {
      return;
    }
    entities.forEach((entity) => {
      entity.setParentEntityNode(entity);
      this.entities.push(entity);
    });
    if (this.entities.length > 0) {
      const lastEntity = this.entities[this.entities.length - 1];
      this.setCurrentId(lastEntity.idValue);
    }
  }
  /**
   * 追加实体
   */
  appendEntity(entity) {
    entity.setParentEntityNode(entity);
    this.entities.push(entity);
    if (this.entities.length > 0) {
      const lastEntity = this.entities[this.entities.length - 1];
      this.setCurrentId(lastEntity.idValue);
    }
  }
  /**
   * 获取全部实体
   */
  getEntities() {
    return this.entities;
  }
  /**
   * 获取当前实体
   */
  getCurrentEntity() {
    if (!this.currentId) {
      return this.createEmpltyEntity();
    }
    const currentEntity = this.getEntityById(this.currentId);
    if (!currentEntity) {
      return this.createEmpltyEntity();
    }
    return currentEntity;
  }
  /**
   * 获取实体
   */
  setCurrentId(id) {
    const currentEntity = this.entities.find((entity) => {
      return entity.idValue === id;
    });
    if (!currentEntity) {
      this.currentId = null;
      return;
    }
    this.currentId = currentEntity.idValue;
  }
  /**
   * 获取实体
   */
  getEntityById(id) {
    const targetEntity = this.entities.find((entity) => {
      return entity.idValue === id;
    });
    return targetEntity;
  }
  /**
   * 删除实体
   */
  removeEntityById(id) {
    const targetIndex = this.entities.findIndex((entity) => {
      return entity.idValue === id;
    });
    if (targetIndex === -1) {
      return;
    }
    const currentEntity = this.getCurrentEntity();
    if (currentEntity.idValue === id) {
      let newCurrentIndex = null;
      if (targetIndex === this.entities.length - 1) {
        newCurrentIndex = targetIndex - 1;
      } else {
        newCurrentIndex = targetIndex + 1;
      }
      const newCurrentEntity = this.entities[newCurrentIndex];
      if (newCurrentEntity) {
        this.setCurrentId(newCurrentEntity.idValue);
      } else {
        this.setCurrentId(null);
      }
    }
    this.entities.splice(targetIndex, 1);
  }
  /**
   * 批量删除实体
   */
  removeEntityByIds(ids) {
    if (!Array.isArray(ids)) {
      return;
    }
    ids.forEach((id) => {
      this.removeEntityById(id);
    });
  }
  /**
   * 转换为JSON对象
   */
  toJSON() {
    const entityListData = this.entities.map((entity) => {
      return entity.toJSON();
    });
    return entityListData;
  }
  /**
   * 创建空实体
   */
  createEmpltyEntity() {
    const emptyEntity = createEntityBySchema(this.entitySchema, {});
    return emptyEntity;
  }
}
function createEntityList(entityType, entityDatas) {
  if (!entityType) {
    throw new Error(`The entityType parameter can't be empty`);
  }
  if (!Array.isArray(entityDatas)) {
    throw new Error(`The entityDatas parameter should be an array`);
  }
  const entitySchema = createEntitySchema(entityType);
  const entityList = createEntityListBySchema(entitySchema, entityDatas);
  return entityList;
}
function createEntityListBySchema(entitySchema, entityDatas) {
  if (!entitySchema) {
    throw new Error(`The entitySchema parameter can't be empty`);
  }
  if (!Array.isArray(entityDatas)) {
    throw new Error(`The entityDatas parameter should be an array`);
  }
  const entityList = new EntityList(entitySchema);
  entityList.loadData(entityDatas);
  return entityList;
}
class EntityDataLoader {
  /**
   * 构造函数
   */
  constructor(entity) {
    /**
     * 实体
     */
    __publicField(this, "entity");
    /**
     * 实体描述
     */
    __publicField(this, "entitySchema");
    this.entity = entity;
    this.entitySchema = entity.getSchema();
  }
  /**
   * 加载数据
   */
  load(entityData) {
    this.loadPrimitiveFields(entityData);
    this.loadEntityFields(entityData);
    this.loadEntityListFields(entityData);
  }
  /**
   * 加载简单字段数据
   */
  loadPrimitiveFields(entityData) {
    const entity = this.entity;
    const fieldSchemas = this.entitySchema.getFieldSchemasByType(FieldType.Primitive);
    fieldSchemas.forEach((fieldSchema) => {
      const propName = fieldSchema.name;
      entity[propName] = entityData[propName];
    });
  }
  /**
   * 加载实体字段数据
   */
  loadEntityFields(entityData) {
    const entity = this.entity;
    const fieldSchemas = this.entitySchema.getFieldSchemasByType(FieldType.Entity);
    fieldSchemas.forEach((fieldSchema) => {
      const propName = fieldSchema.name;
      const childEntitySchema = fieldSchema.entitySchema;
      const childEntityData = entityData[propName] || {};
      const childEntity = createEntityBySchema(childEntitySchema, childEntityData);
      childEntity.setParentEntityNode(entity);
      entity[propName] = childEntity;
    });
  }
  /**
   * 加载实体列表字段数据
   */
  loadEntityListFields(entityData) {
    const entity = this.entity;
    const fieldSchemas = this.entitySchema.getFieldSchemasByType(FieldType.EntityList);
    fieldSchemas.forEach((fieldSchema) => {
      const propName = fieldSchema.name;
      const childEntitySchema = fieldSchema.entitySchema;
      const childEntityListData = entityData[propName] || [];
      const childEntityList = createEntityListBySchema(childEntitySchema, childEntityListData);
      childEntityList.setParentEntityNode(entity);
      entity[propName] = childEntityList;
    });
  }
}
class EntityDataPeeker {
  /**
   * 构造函数
   */
  constructor(entity) {
    /**
     * 实体
     */
    __publicField(this, "entity");
    /**
     * 实体描述
     */
    __publicField(this, "entitySchema");
    this.entity = entity;
    this.entitySchema = entity.getSchema();
  }
  /**
   * 提取数据
   */
  peek() {
    const entityData = {};
    this.peekPrimitiveFields(entityData);
    this.peekEntityFields(entityData);
    this.peekEntityListFields(entityData);
    return entityData;
  }
  /**
   * 提取简单字段数据
   */
  peekPrimitiveFields(entityData) {
    const entity = this.entity;
    const fieldSchemas = this.entitySchema.getFieldSchemasByType(FieldType.Primitive);
    fieldSchemas.forEach((fieldSchema) => {
      const propName = fieldSchema.name;
      entityData[propName] = entity[propName];
    });
  }
  /**
   * 提取实体字段数据
   */
  peekEntityFields(entityData) {
    const entity = this.entity;
    const fieldSchemas = this.entitySchema.getFieldSchemasByType(FieldType.Entity);
    fieldSchemas.forEach((fieldSchema) => {
      const propName = fieldSchema.name;
      const childEntity = entity[propName];
      const childEntityData = childEntity ? childEntity.toJSON() : {};
      entityData[propName] = childEntityData;
    });
  }
  /**
   * 提取实体列表字段数据
   */
  peekEntityListFields(entityData) {
    const entity = this.entity;
    const fieldSchemas = this.entitySchema.getFieldSchemasByType(FieldType.EntityList);
    fieldSchemas.forEach((fieldSchema) => {
      const propName = fieldSchema.name;
      const childEntityList = entity[propName];
      const childEntityListData = childEntityList ? childEntityList.toJSON() : [];
      entityData[propName] = childEntityListData;
    });
  }
}
class Entity extends EntityNode {
  /**
   * 构造函数
   */
  constructor(schema) {
    super();
    /**
     * 实体描述
     */
    __publicField(this, "entitySchema");
    /**
     * 数据加载器
     */
    __publicField(this, "entityDataLoader");
    /**
     * 数据提取器
     */
    __publicField(this, "entityDataPeeker");
    this.entitySchema = schema;
    this.entityDataLoader = new EntityDataLoader(this);
    this.entityDataPeeker = new EntityDataPeeker(this);
  }
  /**
   * 主键
   */
  get idKey() {
    return this.entitySchema.getIdKey();
  }
  /**
   * 主键值
   */
  get idValue() {
    return this[this.idKey];
  }
  /**
   * 获取实体描述
   */
  getSchema() {
    return this.entitySchema;
  }
  /**
   * 加载数据
   */
  loadData(data) {
    this.entityDataLoader.load(data);
  }
  /**
   * 转换为JSON对象
   */
  toJSON() {
    const data = this.entityDataPeeker.peek();
    return data;
  }
}
var EntityChangeType = /* @__PURE__ */ ((EntityChangeType2) => {
  EntityChangeType2["Load"] = "Load";
  EntityChangeType2["Append"] = "Append";
  EntityChangeType2["Remove"] = "Remove";
  EntityChangeType2["Update"] = "Update";
  EntityChangeType2["ValueChange"] = "ValueChange";
  EntityChangeType2["CurrentChange"] = "CurrentChange";
  return EntityChangeType2;
})(EntityChangeType || {});
var EntityChangeStatus = /* @__PURE__ */ ((EntityChangeStatus2) => {
  EntityChangeStatus2["New"] = "New";
  EntityChangeStatus2["Staged"] = "Staged";
  EntityChangeStatus2["Committed"] = "Commited";
  EntityChangeStatus2["Canceled"] = "Canceled";
  return EntityChangeStatus2;
})(EntityChangeStatus || {});
class EntityChangeMerger {
  /**
   * 构造函数
   */
  constructor(changes) {
    /**
     * 合并前的变更
     */
    __publicField(this, "changes");
    /**
     * 合并后的变更
     */
    __publicField(this, "mergedChagnes");
    this.changes = changes;
    this.mergedChagnes = [];
  }
  /**
   * 合并变更
   */
  mergeChanges() {
    this.changes.forEach((change) => {
      this.mergeChange(change);
    });
    return this.mergedChagnes;
  }
  mergeChange(change) {
    if (change.status !== EntityChangeStatus.New) {
      return;
    }
    const clonedChange = Object.assign({}, change);
    switch (clonedChange.type) {
      case EntityChangeType.ValueChange:
        this.mergeChangeValueChange(change);
        break;
      case EntityChangeType.Update:
        this.mergeUpdateChange(change);
        break;
      case EntityChangeType.Remove:
        this.mergeRemoveChange(change);
        break;
    }
  }
  /**
   * 合并值变更
   */
  mergeChangeValueChange(change) {
    const existedMergedChange = this.mergedChagnes.find((mergedChange) => {
      const isSameType = mergedChange.type === EntityChangeType.ValueChange;
      const isSamePath = mergedChange.path.isSame(change.path);
      if (isSameType && isSamePath) {
        return true;
      }
      return false;
    });
    if (existedMergedChange) {
      existedMergedChange.newValue = change.newValue;
    } else {
      this.mergedChagnes.push(change);
    }
  }
  /**
   * 合并更新变更
   */
  mergeUpdateChange(change) {
    Object.keys(change.newEntityData).forEach((propName) => {
      const changeValueChange = this.convertToChangeValueChange(change, propName);
      this.mergeChangeValueChange(changeValueChange);
    });
  }
  /**
   * 合并删除变更
   */
  mergeRemoveChange(change) {
    this.mergedChagnes = this.mergedChagnes.filter((mergedChange) => {