@nocobase/flow-engine 2.1.0-beta.9 → 2.1.0

package/lib/flowEngine.js

@@ -61,8 +61,10 @@ var import_ReactView = require("./ReactView");
 var import_resources = require("./resources");
 var import_emitter = require("./emitter");
 var import_ModelOperationScheduler = __toESM(require("./scheduler/ModelOperationScheduler"));
+var import_loadedPageCache = require("./utils/loadedPageCache");
 var import_utils = require("./utils");
 var _FlowEngine_instances, registerModel_fn;
+const getFlowEngineLoggerLevel = /* @__PURE__ */ __name(() => process.env.NODE_ENV === "production" ? "warn" : "trace", "getFlowEngineLoggerLevel");
 const _FlowEngine = class _FlowEngine {
   /**
    * Constructor. Initializes React view, registers default model and form scopes.
@@ -83,6 +85,28 @@ const _FlowEngine = class _FlowEngine {
      * @private
      */
     __publicField(this, "_modelClasses", import_reactive.observable.shallow(/* @__PURE__ */ new Map()));
+    /**
+     * Registered model entries.
+     * Key is the model class name, value is the model loader entry.
+     * @private
+     */
+    __publicField(this, "_modelLoaders", /* @__PURE__ */ new Map());
+    /**
+     * In-flight model loading promises.
+     * Key is the model class name, value is the loading promise.
+     * @private
+     */
+    __publicField(this, "_loadingModelPromises", /* @__PURE__ */ new Map());
+    /**
+     * Whether model-loader preload has completed in this session.
+     * @private
+     */
+    __publicField(this, "_modelLoadersPreloaded", false);
+    /**
+     * In-flight model-loader preload promise.
+     * @private
+     */
+    __publicField(this, "_modelLoadersPreloadPromise");
     /**
      * Created model instances.
      * Key is the model instance UID, value is the model instance object.
@@ -107,6 +131,7 @@ const _FlowEngine = class _FlowEngine {
      * @private
      */
     __publicField(this, "_savingModels", /* @__PURE__ */ new Map());
+    __publicField(this, "_loadedPageCache", (0, import_loadedPageCache.createLoadedPageCache)());
     /**
      * Flow engine context object.
      * @private
@@ -173,7 +198,7 @@ const _FlowEngine = class _FlowEngine {
       MultiRecordResource: import_resources.MultiRecordResource
     });
     this.logger = (0, import_pino.default)({
-      level: "trace",
+      level: getFlowEngineLoggerLevel(),
       browser: {
         write: {
           fatal: /* @__PURE__ */ __name((o) => console.trace(o), "fatal"),
@@ -372,6 +397,16 @@ const _FlowEngine = class _FlowEngine {
   getEvents() {
     return this._eventRegistry.getEvents();
   }
+  /**
+   * for proxy instance, the #registerModel can't be called.
+   */
+  _registerModel(name, modelClass) {
+    if (this._modelClasses.has(name)) {
+      console.warn(`FlowEngine: Model class with name '${name}' is already registered and will be overwritten.`);
+    }
+    Object.defineProperty(modelClass, "name", { value: name });
+    this._modelClasses.set(name, modelClass);
+  }
   /**
    * Register multiple model classes.
    * @param {Record<string, ModelConstructor>} models Model class map, key is model name, value is model constructor
@@ -384,6 +419,274 @@ const _FlowEngine = class _FlowEngine {
       __privateMethod(this, _FlowEngine_instances, registerModel_fn).call(this, name, modelClass);
     }
   }
+  /**
+   * Register multiple model loader entries.
+   * The `extends` field declares parent class(es) for async subclass discovery via `getSubclassesOfAsync`.
+   * It accepts `string | ModelConstructor | (string | ModelConstructor)[]` and is normalized to `string[]` internally.
+   * @param {FlowModelLoaderInputMap} loaders Model loader input map
+   * @returns {void}
+   * @example
+   * flowEngine.registerModelLoaders({
+   *   DemoModel: {
+   *     extends: 'BaseModel',
+   *     loader: () => import('./models/DemoModel'),
+   *   },
+   * });
+   */
+  registerModelLoaders(loaders) {
+    let changed = false;
+    for (const [name, input] of Object.entries(loaders)) {
+      if (this._modelLoaders.has(name)) {
+        console.warn(`FlowEngine: Model loader with name '${name}' is already registered and will be overwritten.`);
+      }
+      const entry = {
+        loader: input.loader
+      };
+      if (input.extends != null) {
+        const raw = Array.isArray(input.extends) ? input.extends : [input.extends];
+        entry.extends = raw.map((item) => typeof item === "string" ? item : item.name);
+      }
+      this._modelLoaders.set(name, entry);
+      changed = true;
+    }
+    if (changed) {
+      this._modelLoadersPreloaded = false;
+      this._modelLoadersPreloadPromise = void 0;
+    }
+  }
+  /**
+   * Get a registered model class (constructor) asynchronously.
+   * This will first ensure the model loader entry is resolved.
+   * @param {string} name Model class name
+   * @returns {Promise<ModelConstructor | undefined>} Model constructor, or undefined if not found
+   */
+  async getModelClassAsync(name) {
+    await this.ensureModel(name);
+    return this.getModelClass(name);
+  }
+  /**
+   * Get all registered model classes asynchronously.
+   * This will first ensure all registered model loader entries are resolved.
+   * @returns {Promise<Map<string, ModelConstructor>>} Model class map
+   */
+  async getModelClassesAsync() {
+    await this.ensureModels(Array.from(this._modelLoaders.keys()));
+    return this.getModelClasses();
+  }
+  /**
+   * Create and register a model instance asynchronously.
+   * This will first ensure all string-based model references in the model tree are resolved.
+   * @template T FlowModel subclass type, defaults to FlowModel.
+   * @param {CreateModelOptions} options Model creation options
+   * @returns {Promise<T>} Created model instance
+   */
+  async createModelAsync(options, extra) {
+    await this.resolveModelTree(options);
+    return this.createModel(options, extra);
+  }
+  /**
+   * Normalize a loader result into a model constructor.
+   * @param {string} name Model class name
+   * @param {FlowModelLoaderResult} loaded Loader result
+   * @returns {ModelConstructor | null} Normalized model constructor
+   * @private
+   */
+  normalizeModelLoaderResult(name, loaded) {
+    if (typeof loaded === "function") {
+      return loaded;
+    }
+    if (loaded && typeof loaded === "object") {
+      const defaultExport = loaded.default;
+      if (typeof defaultExport === "function") {
+        return defaultExport;
+      }
+      const namedExport = loaded[name];
+      if (typeof namedExport === "function") {
+        return namedExport;
+      }
+    }
+    console.warn(`FlowEngine: model loader for '${name}' did not resolve to a valid model constructor.`);
+    return null;
+  }
+  /**
+   * Collect string-based model names from a model tree.
+   * @param {unknown} data Model tree data
+   * @param {Set<string>} names Model name set
+   * @private
+   */
+  collectModelNamesFromTree(data, names) {
+    if (!data || typeof data !== "object") {
+      return;
+    }
+    if (Array.isArray(data)) {
+      data.forEach((item) => this.collectModelNamesFromTree(item, names));
+      return;
+    }
+    const tree = data;
+    if (typeof tree.use === "string") {
+      names.add(tree.use);
+    }
+    const subModels = tree.subModels;
+    if (!subModels || typeof subModels !== "object") {
+      return;
+    }
+    Object.values(subModels).forEach((value) => {
+      this.collectModelNamesFromTree(value, names);
+    });
+  }
+  /**
+   * Collect additional model names from object-form meta.createModelOptions defaults.
+   * @param {ModelConstructor} modelClass Model class constructor
+   * @param {Set<string>} names Model name set
+   * @private
+   */
+  collectModelNamesFromMetaDefaults(modelClass, names) {
+    var _a;
+    const metaCreate = (_a = modelClass.meta) == null ? void 0 : _a.createModelOptions;
+    if (metaCreate && typeof metaCreate === "object") {
+      this.collectModelNamesFromTree(metaCreate, names);
+    }
+  }
+  /**
+   * Ensure a single model class is available.
+   * @param {string} name Model class name
+   * @returns {Promise<ModelConstructor | null>} Model constructor or null when resolution fails
+   * @private
+   */
+  async ensureModel(name) {
+    const existing = this._modelClasses.get(name);
+    if (existing) {
+      return existing;
+    }
+    const inflight = this._loadingModelPromises.get(name);
+    if (inflight) {
+      return inflight;
+    }
+    const entry = this._modelLoaders.get(name);
+    if (!entry) {
+      console.warn(`FlowEngine: Model entry '${name}' not found. Falling back to ErrorFlowModel when needed.`);
+      return null;
+    }
+    const promise = (async () => {
+      try {
+        const loaded = await entry.loader();
+        const modelClass = this.normalizeModelLoaderResult(name, loaded);
+        if (!modelClass) {
+          return null;
+        }
+        this._registerModel(name, modelClass);
+        return modelClass;
+      } catch (error) {
+        console.warn(`FlowEngine: Failed to load model '${name}'. Falling back to ErrorFlowModel when needed.`, error);
+        return null;
+      } finally {
+        this._loadingModelPromises.delete(name);
+      }
+    })();
+    this._loadingModelPromises.set(name, promise);
+    return promise;
+  }
+  /**
+   * Ensure multiple model classes are available.
+   * @param {string[]} names Model class names
+   * @returns {Promise<EnsureBatchResult>} Batch ensure result
+   * @private
+   */
+  async ensureModels(names) {
+    const requested = Array.from(new Set(names.filter((name) => !!name)));
+    const loaded = [];
+    const failed = [];
+    const results = await Promise.all(
+      requested.map(async (name) => {
+        const modelClass = await this.ensureModel(name);
+        return { name, modelClass };
+      })
+    );
+    results.forEach(({ name, modelClass }) => {
+      if (modelClass) {
+        loaded.push(name);
+      } else {
+        failed.push({ name });
+      }
+    });
+    return { requested, loaded, failed };
+  }
+  /**
+   * Resolve all unresolved string-based model references in a model tree before synchronous creation begins.
+   *
+   * Use this when you already have a model tree object, such as repository-returned data or resolved
+   * `createModelOptions`, and you need to ensure every string `use` in that tree has been loaded and
+   * registered into `_modelClasses` before calling `createModel()`.
+   *
+   * @param {unknown} data Model tree data
+   * @returns {Promise<EnsureBatchResult>} Batch ensure result
+   */
+  async resolveModelTree(data) {
+    const requested = /* @__PURE__ */ new Set();
+    const loaded = /* @__PURE__ */ new Set();
+    const failed = /* @__PURE__ */ new Map();
+    const processed = /* @__PURE__ */ new Set();
+    const pending = /* @__PURE__ */ new Set();
+    this.collectModelNamesFromTree(data, pending);
+    while (pending.size > 0) {
+      const batch = Array.from(pending).filter((name) => !processed.has(name));
+      pending.clear();
+      if (batch.length === 0) {
+        break;
+      }
+      batch.forEach((name) => requested.add(name));
+      const result = await this.ensureModels(batch);
+      result.loaded.forEach((name) => {
+        processed.add(name);
+        loaded.add(name);
+        const modelClass = this.getModelClass(name);
+        if (modelClass) {
+          const discovered = /* @__PURE__ */ new Set();
+          this.collectModelNamesFromMetaDefaults(modelClass, discovered);
+          discovered.forEach((discoveredName) => {
+            if (!processed.has(discoveredName)) {
+              pending.add(discoveredName);
+            }
+          });
+        }
+      });
+      result.failed.forEach((item) => {
+        processed.add(item.name);
+        failed.set(item.name, item);
+      });
+    }
+    return {
+      requested: Array.from(requested),
+      loaded: Array.from(loaded),
+      failed: Array.from(failed.values())
+    };
+  }
+  /**
+   * Preload all currently registered unresolved model loaders.
+   *
+   * This method is intended for flow-settings/discovery style entry points that need registered model
+   * classes to exist before UI is rendered, without requiring callers to know which specific models
+   * will be touched next.
+   *
+   * @returns {Promise<EnsureBatchResult>} Batch ensure result
+   */
+  async preloadModelLoaders() {
+    const unresolved = Array.from(this._modelLoaders.keys()).filter((name) => !this._modelClasses.has(name));
+    if (unresolved.length === 0) {
+      this._modelLoadersPreloaded = true;
+      return { requested: [], loaded: [], failed: [] };
+    }
+    if (this._modelLoadersPreloadPromise) {
+      return this._modelLoadersPreloadPromise;
+    }
+    this._modelLoadersPreloadPromise = (async () => {
+      const result = await this.ensureModels(unresolved);
+      this._modelLoadersPreloaded = result.failed.length === 0;
+      this._modelLoadersPreloadPromise = void 0;
+      return result;
+    })();
+    return this._modelLoadersPreloadPromise;
+  }
   registerResources(resources) {
     for (const [name, resourceClass] of Object.entries(resources)) {
       this._resources.set(name, resourceClass);
@@ -447,6 +750,55 @@ const _FlowEngine = class _FlowEngine {
     }
     return result;
   }
+  /**
+   * Asynchronously get all subclasses of a base class, including those registered via model loaders.
+   * Merges results from already-loaded classes (_modelClasses) and async loader entries with matching `extends` declarations.
+   * Loader-resolved classes are validated with `isInheritedFrom`; mismatches are warned and excluded.
+   * @param {string | ModelConstructor} baseClass Base class name or constructor
+   * @param {(ModelClass: ModelConstructor, className: string) => boolean} [filter] Optional filter function
+   * @returns {Promise<Map<string, ModelConstructor>>} Model classes that are subclasses of the base class
+   */
+  async getSubclassesOfAsync(baseClass, filter) {
+    var _a;
+    const baseClassName = typeof baseClass === "string" ? baseClass : baseClass.name;
+    let parentModelClass;
+    if (typeof baseClass === "string") {
+      if (!this.getModelClass(baseClass)) {
+        await this.ensureModel(baseClass);
+      }
+      parentModelClass = this.getModelClass(baseClass);
+    } else {
+      parentModelClass = baseClass;
+    }
+    if (!parentModelClass) {
+      return /* @__PURE__ */ new Map();
+    }
+    const result = this.getSubclassesOf(parentModelClass, filter);
+    const loaderCandidates = [];
+    for (const [name, entry] of this._modelLoaders) {
+      if (result.has(name) || this._modelClasses.has(name)) continue;
+      if ((_a = entry.extends) == null ? void 0 : _a.includes(baseClassName)) {
+        loaderCandidates.push(name);
+      }
+    }
+    if (loaderCandidates.length > 0) {
+      await this.ensureModels(loaderCandidates);
+    }
+    for (const name of loaderCandidates) {
+      const ModelClass = this._modelClasses.get(name);
+      if (!ModelClass) continue;
+      if (!(0, import_utils.isInheritedFrom)(ModelClass, parentModelClass)) {
+        console.warn(
+          `FlowEngine: Model '${name}' declares extends '${baseClassName}' but does not actually inherit from it. Skipping.`
+        );
+        continue;
+      }
+      if (!filter || filter(ModelClass, name)) {
+        result.set(name, ModelClass);
+      }
+    }
+    return result;
+  }
   /**
    * Create and register a model instance.
    * If an instance with the same UID exists, returns the existing instance.
@@ -510,7 +862,6 @@ const _FlowEngine = class _FlowEngine {
     const visited = /* @__PURE__ */ new Set();
     while (current) {
       if (visited.has(current)) {
-        console.warn(`FlowEngine: resolveUse circular reference detected on '${current.name}'.`);
         break;
       }
       visited.add(current);
@@ -611,7 +962,7 @@ const _FlowEngine = class _FlowEngine {
   removeModel(uid) {
     var _a, _b, _c;
     if (!this._modelInstances.has(uid)) {
-      console.warn(`FlowEngine: Model with UID '${uid}' does not exist.`);
+      this.logger.debug(`FlowEngine: Model with UID '${uid}' does not exist.`);
       return false;
     }
     const modelInstance = this._modelInstances.get(uid);
@@ -732,7 +1083,7 @@ const _FlowEngine = class _FlowEngine {
    * Hydrate a model into current engine from an already-existing model instance in previous engines.
    * - Avoids repository requests when the model tree is already present in memory.
    */
-  hydrateModelFromPreviousEngines(options, extra) {
+  async hydrateModelFromPreviousEngines(options, extra) {
     var _a;
     const uid = options == null ? void 0 : options.uid;
     const parentId = options == null ? void 0 : options.parentId;
@@ -744,7 +1095,7 @@ const _FlowEngine = class _FlowEngine {
       }
       if (existing) {
         const data = existing.serialize();
-        return this.createModel(data, extra);
+        return this.createModelAsync(data, extra);
       }
     }
     if (parentId && subKey) {
@@ -755,10 +1106,10 @@ const _FlowEngine = class _FlowEngine {
       if (!localParent) {
         const parentData = parentFromPrev.serialize();
         delete parentData.subModels;
-        localParent = this.createModel(parentData, extra);
+        localParent = await this.createModelAsync(parentData, extra);
       }
       const modelData = modelFromPrev.serialize();
-      const localModel = this.createModel(modelData, extra);
+      const localModel = await this.createModelAsync(modelData, extra);
       const mounted = (_a = localParent.subModels) == null ? void 0 : _a[subKey];
       if (Array.isArray(mounted)) {
         const exists = mounted.some((m) => (m == null ? void 0 : m.uid) === (localModel == null ? void 0 : localModel.uid));
@@ -789,25 +1140,36 @@ const _FlowEngine = class _FlowEngine {
   async loadModel(options) {
     if (!this.ensureModelRepository()) return;
     const refresh = !!(options == null ? void 0 : options.refresh);
-    if (!refresh) {
-      const model = this.findModelByParentId(options.parentId, options.subKey);
-      if (model) {
-        return model;
+    const bypassLoadedPageCache = this._loadedPageCache.shouldBypass(options, () => this.context.flowSettingsEnabled);
+    if (!refresh && !bypassLoadedPageCache) {
+      const model2 = this.findModelByParentId(options.parentId, options.subKey);
+      if (model2) {
+        return model2;
       }
-      const hydrated = this.hydrateModelFromPreviousEngines(options);
+      const hydrated = await this.hydrateModelFromPreviousEngines(options);
       if (hydrated) {
         return hydrated;
       }
     }
     const data = await this._modelRepository.findOne(options);
-    if (!(data == null ? void 0 : data.uid)) return null;
-    if (refresh) {
+    if (!(data == null ? void 0 : data.uid)) {
+      if (bypassLoadedPageCache) {
+        this._loadedPageCache.clear(options);
+      }
+      return null;
+    }
+    if (refresh || bypassLoadedPageCache) {
       const existing = this.getModel(data.uid);
       if (existing) {
         this.removeModelWithSubModels(existing.uid);
       }
     }
-    return this.createModel(data);
+    const model = await this.createModelAsync(data);
+    if (bypassLoadedPageCache) {
+      this._loadedPageCache.mountModelToParent(model, true);
+      this._loadedPageCache.clear(options);
+    }
+    return model;
   }
   /**
    * Find a sub-model by parent model ID and subKey.
@@ -838,39 +1200,39 @@ const _FlowEngine = class _FlowEngine {
   async loadOrCreateModel(options, extra) {
     if (!this.ensureModelRepository()) return;
     const { uid, parentId, subKey } = options;
-    if (uid && this._modelInstances.has(uid)) {
+    const bypassLoadedPageCache = this._loadedPageCache.shouldBypass(options, () => this.context.flowSettingsEnabled);
+    if (uid && !bypassLoadedPageCache && this._modelInstances.has(uid)) {
       return this._modelInstances.get(uid);
     }
-    const m = this.findModelByParentId(parentId, subKey);
-    if (m) {
-      return m;
-    }
-    const hydrated = this.hydrateModelFromPreviousEngines(options, extra);
-    if (hydrated) {
-      return hydrated;
+    if (!bypassLoadedPageCache) {
+      const m = this.findModelByParentId(parentId, subKey);
+      if (m) {
+        return m;
+      }
+      const hydrated = await this.hydrateModelFromPreviousEngines(options, extra);
+      if (hydrated) {
+        return hydrated;
+      }
     }
     const data = await this._modelRepository.findOne(options);
     let model = null;
     if (data == null ? void 0 : data.uid) {
-      model = this.createModel(data, extra);
+      if (bypassLoadedPageCache) {
+        const existing = this.getModel(data.uid);
+        if (existing) {
+          this.removeModelWithSubModels(existing.uid);
+        }
+      }
+      model = await this.createModelAsync(data, extra);
     } else {
-      model = this.createModel(options, extra);
+      model = await this.createModelAsync(options, extra);
       if (!(extra == null ? void 0 : extra.skipSave)) {
         await model.save();
       }
     }
-    if (model.parent) {
-      const subModel = model.parent.findSubModel(model.subKey, (m2) => {
-        return m2.uid === model.uid;
-      });
-      if (subModel) {
-        return model;
-      }
-      if (model.subType === "array") {
-        model.parent.addSubModel(model.subKey, model);
-      } else {
-        model.parent.setSubModel(model.subKey, model);
-      }
+    this._loadedPageCache.mountModelToParent(model, bypassLoadedPageCache);
+    if (bypassLoadedPageCache) {
+      this._loadedPageCache.clear(options);
     }
     return model;
   }
@@ -888,6 +1250,9 @@ const _FlowEngine = class _FlowEngine {
   async saveModel(model, options) {
     if (!this.ensureModelRepository()) return;
     const modelUid = model.uid;
+    const dirtyLoadedPageKey = this._loadedPageCache.getDirtyKeyForModel(model, {
+      force: !!(options == null ? void 0 : options.onlyStepParams)
+    });
     if (this._savingModels.has(modelUid)) {
       this.logger.debug(`Model ${modelUid} is already being saved, waiting for existing save operation`);
       return await this._savingModels.get(modelUid);
@@ -896,6 +1261,7 @@ const _FlowEngine = class _FlowEngine {
     this._savingModels.set(modelUid, savePromise);
     try {
       const result = await savePromise;
+      this._loadedPageCache.markDirty(dirtyLoadedPageKey);
       return result;
     } finally {
       this._savingModels.delete(modelUid);
@@ -926,10 +1292,15 @@ const _FlowEngine = class _FlowEngine {
    * @returns {Promise<boolean>} Whether destroyed successfully
    */
   async destroyModel(uid) {
-    if (this.ensureModelRepository()) {
+    const modelInstance = this._modelInstances.get(uid);
+    const dirtyLoadedPageKey = this._loadedPageCache.getDirtyKeyForModel(modelInstance);
+    const hasModelRepository = this.ensureModelRepository();
+    if (hasModelRepository) {
       await this._modelRepository.destroy(uid);
     }
-    const modelInstance = this._modelInstances.get(uid);
+    if (hasModelRepository) {
+      this._loadedPageCache.markDirty(dirtyLoadedPageKey);
+    }
     const parent = modelInstance == null ? void 0 : modelInstance.parent;
     const result = this.removeModel(uid);
     parent && parent.emitter.emit("onSubModelDestroyed", modelInstance);
@@ -1005,18 +1376,25 @@ const _FlowEngine = class _FlowEngine {
   }
   /**
    * Move a model instance within its parent model.
-   * @param {any} sourceId Source model UID
-   * @param {any} targetId Target model UID
+   * @param {string | number} sourceId Source model UID
+   * @param {string | number} targetId Target model UID
    * @returns {Promise<void>} No return value
    */
   async moveModel(sourceId, targetId, options) {
     var _a, _b;
-    const sourceModel = this.getModel(sourceId);
-    const targetModel = this.getModel(targetId);
+    const sourceUid = String(sourceId);
+    const targetUid = String(targetId);
+    if (!sourceUid || !targetUid || sourceUid === targetUid) {
+      return;
+    }
+    const sourceModel = this.getModel(sourceUid);
+    const targetModel = this.getModel(targetUid);
     if (!sourceModel || !targetModel) {
       console.warn(`FlowEngine: Cannot move model. Source or target model not found.`);
       return;
     }
+    let position = "after";
+    const dirtyLoadedPageKey = this._loadedPageCache.getDirtyKeyForModel(sourceModel);
     const move = /* @__PURE__ */ __name((sourceModel2, targetModel2) => {
       if (!sourceModel2.parent || !targetModel2.parent || sourceModel2.parent !== targetModel2.parent) {
         console.error("FlowModel.moveTo: Both models must have the same parent to perform move operation.");
@@ -1039,6 +1417,7 @@ const _FlowEngine = class _FlowEngine {
         console.warn("FlowModel.moveTo: Current model is already at the target position. No action taken.");
         return false;
       }
+      position = currentIndex < targetIndex ? "after" : "before";
       const [movedModel] = subModelsCopy.splice(currentIndex, 1);
       subModelsCopy.splice(targetIndex, 0, movedModel);
       subModelsCopy.forEach((model, index) => {
@@ -1047,10 +1426,13 @@ const _FlowEngine = class _FlowEngine {
       subModels.splice(0, subModels.length, ...subModelsCopy);
       return true;
     }, "move");
-    move(sourceModel, targetModel);
+    const moved = move(sourceModel, targetModel);
+    if (!moved) {
+      return;
+    }
     if ((options == null ? void 0 : options.persist) !== false && this.ensureModelRepository()) {
-      const position = sourceModel.sortIndex - targetModel.sortIndex > 0 ? "after" : "before";
-      await this._modelRepository.move(sourceId, targetId, position);
+      await this._modelRepository.move(sourceUid, targetUid, position);
+      this._loadedPageCache.markDirty(dirtyLoadedPageKey);
     }
     sourceModel.parent.emitter.emit("onSubModelMoved", { source: sourceModel, target: targetModel });
     (_b = this.emitter) == null ? void 0 : _b.emit("model:subModel:moved", {
@@ -1098,11 +1480,7 @@ _FlowEngine_instances = new WeakSet();
  * @private
  */
 registerModel_fn = /* @__PURE__ */ __name(function(name, modelClass) {
-  if (this._modelClasses.has(name)) {
-    console.warn(`FlowEngine: Model class with name '${name}' is already registered and will be overwritten.`);
-  }
-  Object.defineProperty(modelClass, "name", { value: name });
-  this._modelClasses.set(name, modelClass);
+  return this._registerModel(name, modelClass);
 }, "#registerModel");
 __name(_FlowEngine, "FlowEngine");
 let FlowEngine = _FlowEngine;

package/lib/flowI18n.js

@@ -71,7 +71,8 @@ const _FlowI18n = class _FlowI18n {
   translateKey(key, options) {
     var _a, _b;
     if ((_b = (_a = this.context) == null ? void 0 : _a.i18n) == null ? void 0 : _b.t) {
-      return this.context.i18n.t(key, options);
+      const translated = this.context.i18n.t(key, options);
+      return translated == null || translated === "" ? key : translated;
     }
     return key;
   }