@nocobase/plugin-flow-engine 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/server/flow-surfaces/compiler.js

@@ -0,0 +1,1129 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compiler_exports = {};
+__export(compiler_exports, {
+  buildAutoLayout: () => buildAutoLayout,
+  compileApplySpec: () => compileApplySpec
+});
+module.exports = __toCommonJS(compiler_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_catalog = require("./catalog");
+var import_placement = require("./placement");
+var import_errors = require("./errors");
+function makeOpRef(path) {
+  return { ref: path };
+}
+const FORM_GRID_USES = /* @__PURE__ */ new Set(["FormGridModel", "AssignFormGridModel"]);
+const ACTION_USES = new Set(Array.from(import_catalog.ACTION_KEY_BY_USE.keys()));
+const BLOCK_USES = new Set(Array.from(import_catalog.BLOCK_KEY_BY_USE.keys()));
+const FIELD_WRAPPER_USES = import_placement.FLOW_SURFACE_FIELD_WRAPPER_USES;
+const STANDALONE_FIELD_USES = /* @__PURE__ */ new Set(["JSColumnModel", "JSItemModel"]);
+const FORM_BLOCK_USES = import_placement.FLOW_SURFACE_FORM_BLOCK_USES;
+const DETAILS_BLOCK_USES = import_placement.FLOW_SURFACE_DETAILS_BLOCK_USES;
+const FILTER_FORM_BLOCK_USES = import_placement.FLOW_SURFACE_FILTER_FORM_BLOCK_USES;
+const RECORD_ACTION_INTERNAL_CONTAINER_USES = /* @__PURE__ */ new Set([
+  "TableActionsColumnModel",
+  "ListItemModel",
+  "GridCardItemModel"
+]);
+function compileApplySpec(target, currentTree, spec) {
+  if (!(currentTree == null ? void 0 : currentTree.uid) || !(currentTree == null ? void 0 : currentTree.use)) {
+    throw new import_errors.FlowSurfaceBadRequestError("flowSurfaces apply requires an existing target subtree");
+  }
+  const ops = [];
+  const state = {
+    seq: 0,
+    clientKeyToUid: {}
+  };
+  if (currentTree.use === "RootPageModel") {
+    syncRoutePageNode(ops, state, target, currentTree, spec);
+    return {
+      ops,
+      clientKeyToUid: state.clientKeyToUid
+    };
+  }
+  if (currentTree.use === "ChildPageModel") {
+    syncExistingNode(
+      ops,
+      state,
+      {
+        uidRef: currentTree.uid,
+        use: currentTree.use
+      },
+      currentTree,
+      {
+        uid: currentTree.uid,
+        use: currentTree.use,
+        props: spec.props,
+        decoratorProps: spec.decoratorProps,
+        stepParams: spec.stepParams,
+        flowRegistry: spec.flowRegistry,
+        subModels: spec.subModels
+      },
+      { uid: currentTree.uid }
+    );
+    return {
+      ops,
+      clientKeyToUid: state.clientKeyToUid
+    };
+  }
+  if (currentTree.use === "RootPageTabModel") {
+    syncRouteTabNode(ops, state, target, currentTree, spec);
+    return {
+      ops,
+      clientKeyToUid: state.clientKeyToUid
+    };
+  }
+  if (currentTree.use === "ChildPageTabModel") {
+    syncTabNode(ops, state, { uid: currentTree.uid }, currentTree, spec);
+    return {
+      ops,
+      clientKeyToUid: state.clientKeyToUid
+    };
+  }
+  const rootSpec = {
+    uid: currentTree.uid,
+    use: currentTree.use,
+    props: spec.props,
+    decoratorProps: spec.decoratorProps,
+    stepParams: spec.stepParams,
+    flowRegistry: spec.flowRegistry,
+    subModels: spec.subModels
+  };
+  syncExistingNode(
+    ops,
+    state,
+    {
+      uidRef: currentTree.uid,
+      use: currentTree.use
+    },
+    currentTree,
+    rootSpec,
+    target
+  );
+  return {
+    ops,
+    clientKeyToUid: state.clientKeyToUid
+  };
+}
+function syncExistingNode(ops, state, nodeRef, currentNode, desiredNode, explicitTarget) {
+  emitDomainSettingOps(ops, nodeRef, currentNode, desiredNode, explicitTarget);
+  const childSync = syncChildren(ops, state, nodeRef, currentNode, desiredNode);
+  emitLayoutOp(ops, explicitTarget || { uid: nodeRef.uidRef }, currentNode, desiredNode, childSync);
+}
+function syncCreatedNode(ops, state, nodeRef, desiredNode) {
+  emitDomainSettingOps(ops, nodeRef, null, desiredNode);
+  const childSync = syncChildren(ops, state, nodeRef, null, desiredNode);
+  emitLayoutOp(ops, { uid: nodeRef.uidRef }, null, desiredNode, childSync);
+}
+function syncRoutePageNode(ops, state, target, currentNode, desiredNode) {
+  const pageTarget = { uid: String(target.uid || currentNode.uid || "").trim() };
+  syncPageNode(ops, state, pageTarget, currentNode, desiredNode);
+}
+function syncPageNode(ops, state, pageTarget, currentNode, desiredNode) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  emitDomainSettingOps(
+    ops,
+    {
+      uidRef: currentNode.uid,
+      use: currentNode.use
+    },
+    currentNode,
+    {
+      uid: currentNode.uid,
+      use: currentNode.use,
+      props: desiredNode.props,
+      decoratorProps: desiredNode.decoratorProps,
+      stepParams: desiredNode.stepParams,
+      flowRegistry: desiredNode.flowRegistry
+    },
+    pageTarget
+  );
+  if (!hasExplicitSubModelKey(desiredNode, "tabs")) {
+    return;
+  }
+  const hasTabsSpec = Object.prototype.hasOwnProperty.call(desiredNode.subModels || {}, "tabs");
+  if (!hasTabsSpec) {
+    return;
+  }
+  const desiredTabs = normalizeChildren((_a = desiredNode.subModels) == null ? void 0 : _a.tabs);
+  const currentTabs = normalizeChildren((_b = currentNode.subModels) == null ? void 0 : _b.tabs);
+  const tabMatchPlan = planArrayChildMatches(currentTabs, desiredTabs, currentNode.use, "tabs");
+  const desiredRefs = [];
+  for (const [desiredIndex, desiredTab] of desiredTabs.entries()) {
+    const currentMatch = tabMatchPlan.matchesByDesiredIndex.get(desiredIndex);
+    if (currentMatch) {
+      bindClientKey(state, desiredTab.clientKey, currentMatch.uid);
+      desiredRefs.push({
+        uidRef: currentMatch.uid,
+        use: currentMatch.use
+      });
+      syncRouteTabNode(ops, state, { uid: currentMatch.uid }, currentMatch, desiredTab);
+      continue;
+    }
+    const opId = nextOpId(state, "addTab");
+    ops.push({
+      opId,
+      type: "addTab",
+      values: {
+        target: pageTarget,
+        ...desiredTab.clientKey ? { clientKey: desiredTab.clientKey } : {},
+        title: ((_e = (_d = (_c = desiredTab == null ? void 0 : desiredTab.stepParams) == null ? void 0 : _c.pageTabSettings) == null ? void 0 : _d.tab) == null ? void 0 : _e.title) || ((_f = desiredTab == null ? void 0 : desiredTab.props) == null ? void 0 : _f.title) || ((_h = (_g = desiredTab == null ? void 0 : desiredTab.props) == null ? void 0 : _g.route) == null ? void 0 : _h.title) || "Untitled",
+        icon: ((_k = (_j = (_i = desiredTab == null ? void 0 : desiredTab.stepParams) == null ? void 0 : _i.pageTabSettings) == null ? void 0 : _j.tab) == null ? void 0 : _k.icon) || ((_l = desiredTab == null ? void 0 : desiredTab.props) == null ? void 0 : _l.icon),
+        documentTitle: (_o = (_n = (_m = desiredTab == null ? void 0 : desiredTab.stepParams) == null ? void 0 : _m.pageTabSettings) == null ? void 0 : _n.tab) == null ? void 0 : _o.documentTitle,
+        flowRegistry: desiredTab == null ? void 0 : desiredTab.flowRegistry
+      }
+    });
+    const createdRef = {
+      uidRef: makeOpRef(`${opId}.tabSchemaUid`),
+      use: "RootPageTabModel",
+      sourceOpId: opId
+    };
+    desiredRefs.push(createdRef);
+    syncCreatedNode(ops, state, createdRef, desiredTab);
+  }
+  for (const currentTab of currentTabs) {
+    if (!tabMatchPlan.matchedCurrentUids.has(currentTab.uid)) {
+      ops.push({
+        type: "removeTab",
+        values: {
+          uid: currentTab.uid
+        }
+      });
+    }
+  }
+  emitMoveTabOps(ops, desiredRefs);
+}
+function syncRouteTabNode(ops, state, target, currentNode, desiredNode) {
+  const tabTarget = { uid: String(target.uid || currentNode.uid || "").trim() };
+  syncTabNode(ops, state, tabTarget, currentNode, desiredNode);
+}
+function syncTabNode(ops, state, tabTarget, currentNode, desiredNode) {
+  var _a, _b;
+  emitDomainSettingOps(
+    ops,
+    {
+      uidRef: currentNode.uid,
+      use: currentNode.use
+    },
+    currentNode,
+    {
+      uid: currentNode.uid,
+      use: currentNode.use,
+      props: desiredNode.props,
+      decoratorProps: desiredNode.decoratorProps,
+      stepParams: desiredNode.stepParams,
+      flowRegistry: desiredNode.flowRegistry
+    },
+    tabTarget
+  );
+  if (!hasExplicitSubModelKey(desiredNode, "grid")) {
+    return;
+  }
+  const hasGridSpec = Object.prototype.hasOwnProperty.call(desiredNode.subModels || {}, "grid");
+  if (!hasGridSpec) {
+    return;
+  }
+  const desiredGrid = normalizeChildren((_a = desiredNode.subModels) == null ? void 0 : _a.grid)[0];
+  const currentGrid = normalizeChildren((_b = currentNode.subModels) == null ? void 0 : _b.grid)[0];
+  if (!desiredGrid || !currentGrid) {
+    return;
+  }
+  syncExistingNode(
+    ops,
+    state,
+    {
+      uidRef: currentGrid.uid,
+      use: currentGrid.use
+    },
+    currentGrid,
+    desiredGrid,
+    { uid: currentGrid.uid }
+  );
+}
+function syncChildren(ops, state, parentRef, currentParent, desiredParent) {
+  const result = {
+    childClientKeyRefs: {},
+    finalItemRefs: [],
+    itemsChanged: false,
+    itemsSpecified: false
+  };
+  const desiredSubModels = desiredParent.subModels;
+  if (!desiredSubModels) {
+    return result;
+  }
+  const currentSubModels = (currentParent == null ? void 0 : currentParent.subModels) || {};
+  const subKeys = Object.keys(desiredSubModels);
+  for (const subKey of subKeys) {
+    const desiredRaw = desiredSubModels[subKey];
+    const currentRaw = currentSubModels[subKey];
+    const desiredChildren = normalizeChildren(desiredRaw);
+    const currentChildren = normalizeChildren(currentRaw);
+    const isArraySubModel = Array.isArray(desiredRaw) || Array.isArray(currentRaw);
+    if (parentRef.use === "ChildPageModel" && subKey === "tabs") {
+      const tabSync = syncPopupTabs(ops, state, parentRef, currentChildren, desiredChildren);
+      if (tabSync.itemsSpecified) {
+        result.finalItemRefs = tabSync.finalItemRefs;
+        result.itemsChanged = tabSync.itemsChanged;
+        result.itemsSpecified = true;
+      }
+      Object.assign(result.childClientKeyRefs, tabSync.childClientKeyRefs);
+      continue;
+    }
+    if (!isArraySubModel) {
+      const desiredChild = desiredChildren[0];
+      const currentChild = currentChildren[0];
+      if (!desiredChild && currentChild) {
+        ops.push({
+          type: "removeNode",
+          target: { uid: currentChild.uid }
+        });
+        continue;
+      }
+      if (!desiredChild) {
+        continue;
+      }
+      if (currentChild && matchesObjectChild(currentChild, desiredChild)) {
+        bindClientKey(state, desiredChild.clientKey, currentChild.uid);
+        if (desiredChild.clientKey) {
+          result.childClientKeyRefs[desiredChild.clientKey] = currentChild.uid;
+        }
+        syncExistingNode(
+          ops,
+          state,
+          {
+            uidRef: currentChild.uid,
+            use: currentChild.use
+          },
+          currentChild,
+          desiredChild
+        );
+        continue;
+      }
+      if (currentChild) {
+        ops.push({
+          type: "removeNode",
+          target: { uid: currentChild.uid }
+        });
+      }
+      const defaultRef = getDefaultChildRef(parentRef, subKey, desiredChild.use);
+      if (defaultRef) {
+        if (desiredChild.clientKey) {
+          result.childClientKeyRefs[desiredChild.clientKey] = defaultRef.uidRef;
+        }
+        syncCreatedNode(ops, state, defaultRef, desiredChild);
+      } else {
+        const createdRef = createDesiredChild(ops, state, parentRef, subKey, desiredChild, currentParent);
+        if (desiredChild.clientKey) {
+          result.childClientKeyRefs[desiredChild.clientKey] = createdRef.uidRef;
+        }
+      }
+      continue;
+    }
+    const childMatchPlan = planArrayChildMatches(currentChildren, desiredChildren, parentRef.use, subKey);
+    const desiredRefs = [];
+    for (const [desiredIndex, desiredChild] of desiredChildren.entries()) {
+      const currentMatch = childMatchPlan.matchesByDesiredIndex.get(desiredIndex);
+      if (currentMatch) {
+        const currentRef = {
+          uidRef: currentMatch.uid,
+          use: currentMatch.use
+        };
+        bindClientKey(state, desiredChild.clientKey, currentMatch.uid);
+        if (desiredChild.clientKey) {
+          result.childClientKeyRefs[desiredChild.clientKey] = currentRef.uidRef;
+        }
+        desiredRefs.push(currentRef);
+        syncExistingNode(ops, state, currentRef, currentMatch, desiredChild);
+        continue;
+      }
+      const defaultRef = getDefaultChildRef(parentRef, subKey, desiredChild.use);
+      if (defaultRef) {
+        if (desiredChild.clientKey) {
+          result.childClientKeyRefs[desiredChild.clientKey] = defaultRef.uidRef;
+        }
+        desiredRefs.push(defaultRef);
+        syncCreatedNode(ops, state, defaultRef, desiredChild);
+        continue;
+      }
+      const createdRef = createDesiredChild(ops, state, parentRef, subKey, desiredChild, currentParent);
+      if (desiredChild.clientKey) {
+        result.childClientKeyRefs[desiredChild.clientKey] = createdRef.uidRef;
+      }
+      desiredRefs.push(createdRef);
+    }
+    for (const currentChild of currentChildren) {
+      if (!childMatchPlan.matchedCurrentUids.has(currentChild.uid)) {
+        ops.push({
+          type: "removeNode",
+          target: { uid: currentChild.uid }
+        });
+      }
+    }
+    emitMoveOps(ops, desiredRefs);
+    if (subKey === "items") {
+      result.finalItemRefs = desiredRefs;
+      result.itemsChanged = didItemRefsChange(currentChildren, desiredRefs);
+      result.itemsSpecified = true;
+    }
+  }
+  return result;
+}
+function createDesiredChild(ops, state, parentRef, subKey, desiredChild, currentParent) {
+  if (desiredChild.use === "ChildPageModel" && (0, import_placement.isPopupHostUse)(parentRef.use)) {
+    compilePopupPageSpec(ops, state, parentRef, desiredChild);
+    return {
+      uidRef: parentRef.uidRef,
+      use: desiredChild.use,
+      sourceOpId: parentRef.sourceOpId
+    };
+  }
+  if ((isFieldWrapperNode(desiredChild.use) || STANDALONE_FIELD_USES.has(desiredChild.use)) && isFieldContainer(parentRef.use, subKey)) {
+    return createFieldNode(ops, state, parentRef, desiredChild);
+  }
+  if (subKey === "actions" && isActionContainer(parentRef.use)) {
+    if (!ACTION_USES.has(desiredChild.use)) {
+      throw new import_errors.FlowSurfaceBadRequestError(
+        `flowSurfaces apply action '${desiredChild.use}' is not a public capability`
+      );
+    }
+    return createActionNode(ops, state, parentRef, desiredChild, currentParent);
+  }
+  if (isBlockContainer(parentRef.use, subKey)) {
+    if (!BLOCK_USES.has(desiredChild.use)) {
+      throw new import_errors.FlowSurfaceBadRequestError(`flowSurfaces apply block '${desiredChild.use}' is not a public capability`);
+    }
+    return createBlockNode(ops, state, parentRef, desiredChild);
+  }
+  if (isFieldContainer(parentRef.use, subKey) && !FIELD_WRAPPER_USES.has(desiredChild.use) && !STANDALONE_FIELD_USES.has(desiredChild.use)) {
+    throw new import_errors.FlowSurfaceBadRequestError(
+      `flowSurfaces apply field wrapper '${desiredChild.use}' is not a public capability`
+    );
+  }
+  throw new import_errors.FlowSurfaceBadRequestError(
+    `flowSurfaces apply cannot create '${desiredChild.use}' under '${parentRef.use}.${subKey}'`
+  );
+}
+function createBlockNode(ops, state, parentRef, desiredNode) {
+  const blockCatalogItem = (0, import_catalog.resolveSupportedBlockCatalogItem)(
+    {
+      use: desiredNode.use
+    },
+    {
+      requireCreateSupported: true
+    }
+  );
+  const opId = nextOpId(state, "addBlock");
+  ops.push({
+    opId,
+    type: "addBlock",
+    values: {
+      target: {
+        uid: parentRef.uidRef
+      },
+      ...desiredNode.clientKey ? { clientKey: desiredNode.clientKey } : {},
+      type: blockCatalogItem.key,
+      resourceInit: extractResourceInit(desiredNode)
+    }
+  });
+  const ref = {
+    uidRef: makeOpRef(`${opId}.uid`),
+    use: desiredNode.use,
+    sourceOpId: opId
+  };
+  syncCreatedNode(ops, state, ref, desiredNode);
+  return ref;
+}
+function createActionNode(ops, state, parentRef, desiredNode, currentParent) {
+  const actionCatalogItem = (0, import_catalog.resolveSupportedActionCatalogItem)(
+    {
+      use: desiredNode.use,
+      containerUse: parentRef.use
+    },
+    {
+      requireCreateSupported: true
+    }
+  );
+  const opType = actionCatalogItem.scope === "record" ? "addRecordAction" : "addAction";
+  const targetUidRef = actionCatalogItem.scope === "record" ? resolveRecordActionCreateTargetUidRef(parentRef, currentParent) : parentRef.uidRef;
+  const opId = nextOpId(state, opType);
+  ops.push({
+    opId,
+    type: opType,
+    values: {
+      target: {
+        uid: targetUidRef
+      },
+      ...desiredNode.clientKey ? { clientKey: desiredNode.clientKey } : {},
+      type: actionCatalogItem.key,
+      resourceInit: extractResourceInit(desiredNode)
+    }
+  });
+  const ref = {
+    uidRef: makeOpRef(`${opId}.uid`),
+    use: desiredNode.use,
+    sourceOpId: opId
+  };
+  syncCreatedNode(ops, state, ref, desiredNode);
+  return ref;
+}
+function createFieldNode(ops, state, parentRef, desiredNode) {
+  var _a;
+  const standaloneType = desiredNode.use === "JSColumnModel" ? "jsColumn" : desiredNode.use === "JSItemModel" ? "jsItem" : void 0;
+  if (standaloneType) {
+    const opId2 = nextOpId(state, "addField");
+    ops.push({
+      opId: opId2,
+      type: "addField",
+      values: {
+        target: {
+          uid: parentRef.uidRef
+        },
+        ...desiredNode.clientKey ? { clientKey: desiredNode.clientKey } : {},
+        type: standaloneType
+      }
+    });
+    const ref2 = {
+      uidRef: makeOpRef(`${opId2}.uid`),
+      use: desiredNode.use,
+      sourceOpId: opId2
+    };
+    syncCreatedNode(ops, state, ref2, desiredNode);
+    return ref2;
+  }
+  const innerField = normalizeChildren((_a = desiredNode.subModels) == null ? void 0 : _a.field)[0];
+  const requestedRenderer = (innerField == null ? void 0 : innerField.use) === "JSFieldModel" || (innerField == null ? void 0 : innerField.use) === "JSEditableFieldModel" ? "js" : void 0;
+  const fieldCapability = (0, import_catalog.resolveSupportedFieldCapability)({
+    containerUse: parentRef.use,
+    requestedWrapperUse: desiredNode.use,
+    requestedFieldUse: innerField == null ? void 0 : innerField.use,
+    requestedRenderer,
+    allowUnresolvedFieldUse: true
+  });
+  const fieldInit = import_lodash.default.get(innerField, ["stepParams", "fieldSettings", "init"]) || import_lodash.default.get(desiredNode, ["stepParams", "fieldSettings", "init"]);
+  const defaultTargetUid = import_lodash.default.get(desiredNode, ["stepParams", "filterFormItemSettings", "init", "defaultTargetUid"]);
+  if (!(fieldInit == null ? void 0 : fieldInit.fieldPath)) {
+    throw new import_errors.FlowSurfaceBadRequestError(
+      `flowSurfaces apply field '${desiredNode.use}' requires stepParams.fieldSettings.init.fieldPath`
+    );
+  }
+  const opId = nextOpId(state, "addField");
+  ops.push({
+    opId,
+    type: "addField",
+    values: {
+      target: {
+        uid: parentRef.uidRef
+      },
+      ...desiredNode.clientKey ? { clientKey: desiredNode.clientKey } : {},
+      fieldPath: fieldInit.fieldPath,
+      associationPathName: fieldInit.associationPathName,
+      dataSourceKey: fieldInit.dataSourceKey,
+      collectionName: fieldInit.collectionName,
+      ...requestedRenderer ? { renderer: requestedRenderer } : {},
+      ...fieldCapability.fieldUse ? { fieldUse: fieldCapability.fieldUse } : {},
+      ...defaultTargetUid ? { defaultTargetUid } : {}
+    }
+  });
+  const ref = {
+    uidRef: makeOpRef(`${opId}.wrapperUid`),
+    use: desiredNode.use,
+    sourceOpId: opId
+  };
+  syncCreatedNode(ops, state, ref, desiredNode);
+  return ref;
+}
+function compilePopupPageSpec(ops, state, hostRef, pageSpec) {
+  var _a, _b, _c;
+  const tabSpec = normalizeChildren((_a = pageSpec.subModels) == null ? void 0 : _a.tabs)[0];
+  const gridSpec = normalizeChildren((_b = tabSpec == null ? void 0 : tabSpec.subModels) == null ? void 0 : _b.grid)[0];
+  const popupItems = normalizeChildren((_c = gridSpec == null ? void 0 : gridSpec.subModels) == null ? void 0 : _c.items);
+  if (!tabSpec || !gridSpec) {
+    throw new import_errors.FlowSurfaceBadRequestError(
+      `flowSurfaces apply popup page creation under '${hostRef.use}' requires popup page -> tab -> grid`
+    );
+  }
+  const { childRefs, childClientKeyRefs, popupGridUidRef, popupPageRef, popupTabRef, placeholderRef } = bootstrapPopupShellCreation(ops, state, hostRef, pageSpec, tabSpec, popupItems);
+  if (popupPageRef) {
+    emitDomainSettingOps(ops, popupPageRef, null, pageSpec);
+  }
+  if (popupTabRef) {
+    emitDomainSettingOps(ops, popupTabRef, null, tabSpec);
+  }
+  if (popupGridUidRef) {
+    emitDomainSettingOps(
+      ops,
+      {
+        uidRef: popupGridUidRef,
+        use: gridSpec.use
+      },
+      null,
+      gridSpec
+    );
+    if (placeholderRef) {
+      ops.push({
+        type: "removeNode",
+        values: {
+          target: {
+            uid: placeholderRef.uidRef
+          }
+        }
+      });
+    }
+    emitLayoutOp(ops, { uid: popupGridUidRef }, null, gridSpec, {
+      childClientKeyRefs,
+      finalItemRefs: childRefs,
+      itemsChanged: true,
+      itemsSpecified: true
+    });
+    emitMoveOps(ops, childRefs);
+  }
+}
+function bootstrapPopupShellCreation(ops, state, hostRef, pageSpec, tabSpec, popupItems) {
+  const result = {
+    childRefs: [],
+    childClientKeyRefs: {},
+    popupGridUidRef: null,
+    popupPageRef: null,
+    popupTabRef: null,
+    placeholderRef: null
+  };
+  const bindPopupShellRefs = (created) => {
+    result.popupPageRef = {
+      uidRef: makeOpRef(`${created.sourceOpId}.popupPageUid`),
+      use: pageSpec.use
+    };
+    result.popupTabRef = {
+      uidRef: makeOpRef(`${created.sourceOpId}.popupTabUid`),
+      use: tabSpec.use,
+      sourceOpId: created.sourceOpId
+    };
+    result.popupGridUidRef = makeOpRef(`${created.sourceOpId}.popupGridUid`);
+  };
+  if (!popupItems.length) {
+    result.placeholderRef = createBlockNode(ops, state, hostRef, {
+      use: "MarkdownBlockModel"
+    });
+    bindPopupShellRefs(result.placeholderRef);
+    return result;
+  }
+  popupItems.forEach((itemSpec, index) => {
+    if (index === 0) {
+      const created2 = createBlockNode(ops, state, hostRef, itemSpec);
+      result.childRefs.push(created2);
+      if (itemSpec.clientKey) {
+        result.childClientKeyRefs[itemSpec.clientKey] = created2.uidRef;
+      }
+      bindPopupShellRefs(created2);
+      return;
+    }
+    const popupGridRef = {
+      uidRef: result.popupGridUidRef,
+      use: "BlockGridModel"
+    };
+    const created = createBlockNode(ops, state, popupGridRef, itemSpec);
+    if (itemSpec.clientKey) {
+      result.childClientKeyRefs[itemSpec.clientKey] = created.uidRef;
+    }
+    result.childRefs.push(created);
+  });
+  return result;
+}
+function emitDomainSettingOps(ops, nodeRef, currentNode, desiredNode, explicitTarget) {
+  const props = omitLayoutProps(desiredNode.props);
+  const currentProps = omitLayoutProps(currentNode == null ? void 0 : currentNode.props);
+  const values = {};
+  if (!import_lodash.default.isNil(props) && !import_lodash.default.isEqual(props, currentProps)) {
+    values.props = props;
+  }
+  if (!import_lodash.default.isNil(desiredNode.decoratorProps) && !import_lodash.default.isEqual(desiredNode.decoratorProps, currentNode == null ? void 0 : currentNode.decoratorProps)) {
+    values.decoratorProps = desiredNode.decoratorProps;
+  }
+  if (!import_lodash.default.isNil(desiredNode.stepParams) && !import_lodash.default.isEqual(desiredNode.stepParams, currentNode == null ? void 0 : currentNode.stepParams)) {
+    values.stepParams = desiredNode.stepParams;
+  }
+  if (Object.keys(values).length) {
+    ops.push({
+      type: "updateSettings",
+      target: explicitTarget || { uid: nodeRef.uidRef },
+      values
+    });
+  }
+  if (!import_lodash.default.isNil(desiredNode.flowRegistry) && !import_lodash.default.isEqual(desiredNode.flowRegistry, currentNode == null ? void 0 : currentNode.flowRegistry)) {
+    ops.push({
+      type: "setEventFlows",
+      target: explicitTarget || { uid: nodeRef.uidRef },
+      values: {
+        flowRegistry: desiredNode.flowRegistry
+      }
+    });
+  }
+}
+function emitLayoutOp(ops, target, currentNode, desiredNode, childSync) {
+  const explicitLayout = resolveLayoutRefs(extractLayout(desiredNode.props), childSync.childClientKeyRefs);
+  const desiredLayout = explicitLayout || (isGridNode((currentNode == null ? void 0 : currentNode.use) || desiredNode.use) && childSync.itemsSpecified ? buildAutoLayout(childSync.finalItemRefs.map((item) => item.uidRef)) : null);
+  if (!desiredLayout) {
+    return;
+  }
+  if (!hasRefValue(desiredLayout) && import_lodash.default.isEqual(desiredLayout, extractLayout(currentNode == null ? void 0 : currentNode.props))) {
+    return;
+  }
+  ops.push({
+    type: "setLayout",
+    target,
+    values: desiredLayout
+  });
+}
+function emitMoveOps(ops, desiredRefs) {
+  for (let index = desiredRefs.length - 2; index >= 0; index -= 1) {
+    ops.push({
+      type: "moveNode",
+      values: {
+        sourceUid: desiredRefs[index].uidRef,
+        targetUid: desiredRefs[index + 1].uidRef,
+        position: "before"
+      }
+    });
+  }
+}
+function getDefaultChildRef(parentRef, subKey, childUse) {
+  if (!parentRef.sourceOpId || !childUse) {
+    return null;
+  }
+  if (FORM_BLOCK_USES.has(parentRef.use) && subKey === "grid" && FORM_GRID_USES.has(childUse)) {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.gridUid`),
+      use: childUse
+    };
+  }
+  if (DETAILS_BLOCK_USES.has(parentRef.use) && subKey === "grid" && childUse === "DetailsGridModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.gridUid`),
+      use: childUse
+    };
+  }
+  if (FILTER_FORM_BLOCK_USES.has(parentRef.use) && subKey === "grid" && childUse === "FilterFormGridModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.gridUid`),
+      use: childUse
+    };
+  }
+  if (parentRef.use === "ChildPageTabModel" && subKey === "grid" && childUse === "BlockGridModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.popupGridUid`),
+      use: childUse
+    };
+  }
+  if (parentRef.use === "TableBlockModel" && subKey === "columns" && childUse === "TableActionsColumnModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.actionsColumnUid`),
+      use: childUse,
+      sourceOpId: parentRef.sourceOpId,
+      ownerUidRef: parentRef.uidRef
+    };
+  }
+  if (parentRef.use === "ListBlockModel" && subKey === "item" && childUse === "ListItemModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.itemUid`),
+      use: childUse,
+      sourceOpId: parentRef.sourceOpId,
+      ownerUidRef: parentRef.uidRef
+    };
+  }
+  if (parentRef.use === "GridCardBlockModel" && subKey === "item" && childUse === "GridCardItemModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.itemUid`),
+      use: childUse,
+      sourceOpId: parentRef.sourceOpId,
+      ownerUidRef: parentRef.uidRef
+    };
+  }
+  if (parentRef.use === "ListItemModel" && subKey === "grid" && childUse === "DetailsGridModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.gridUid`),
+      use: childUse
+    };
+  }
+  if (parentRef.use === "GridCardItemModel" && subKey === "grid" && childUse === "DetailsGridModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.gridUid`),
+      use: childUse
+    };
+  }
+  if (FIELD_WRAPPER_USES.has(parentRef.use) && subKey === "field") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.fieldUid`),
+      use: childUse
+    };
+  }
+  if (parentRef.use === "RootPageTabModel" && subKey === "grid" && childUse === "BlockGridModel") {
+    return {
+      uidRef: makeOpRef(`${parentRef.sourceOpId}.gridUid`),
+      use: childUse
+    };
+  }
+  return null;
+}
+function resolveRecordActionCreateTargetUidRef(parentRef, currentParent) {
+  if (!RECORD_ACTION_INTERNAL_CONTAINER_USES.has(parentRef.use)) {
+    return parentRef.uidRef;
+  }
+  const ownerUidRef = parentRef.ownerUidRef ?? (currentParent == null ? void 0 : currentParent.parentId);
+  if (ownerUidRef) {
+    return ownerUidRef;
+  }
+  throw new import_errors.FlowSurfaceBadRequestError(
+    `flowSurfaces apply cannot resolve owning surface for record action container '${parentRef.use}'`
+  );
+}
+function normalizeChildren(input) {
+  if (!input) {
+    return [];
+  }
+  return import_lodash.default.castArray(input).filter(Boolean);
+}
+function hasExplicitSubModelKey(node, key) {
+  return !!(node == null ? void 0 : node.subModels) && Object.prototype.hasOwnProperty.call(node.subModels, key);
+}
+function matchesObjectChild(currentChild, desiredChild) {
+  return currentChild.uid === desiredChild.uid || !desiredChild.uid && currentChild.use === desiredChild.use;
+}
+function planArrayChildMatches(currentChildren, desiredChildren, parentUse, subKey) {
+  const matchesByDesiredIndex = /* @__PURE__ */ new Map();
+  const matchedCurrentUids = /* @__PURE__ */ new Set();
+  const remainingDesiredByUse = /* @__PURE__ */ new Map();
+  for (const [desiredIndex, desiredChild] of desiredChildren.entries()) {
+    const matchedCurrent = findExactArrayChildMatch(currentChildren, desiredChild, matchedCurrentUids);
+    if (matchedCurrent) {
+      matchesByDesiredIndex.set(desiredIndex, matchedCurrent);
+      if (matchedCurrent.uid) {
+        matchedCurrentUids.add(matchedCurrent.uid);
+      }
+      continue;
+    }
+    if ((desiredChild == null ? void 0 : desiredChild.use) && !desiredChild.uid) {
+      const desiredIndexes = remainingDesiredByUse.get(desiredChild.use) || [];
+      desiredIndexes.push(desiredIndex);
+      remainingDesiredByUse.set(desiredChild.use, desiredIndexes);
+    }
+  }
+  const remainingCurrentByUse = /* @__PURE__ */ new Map();
+  for (const currentChild of currentChildren) {
+    if (!(currentChild == null ? void 0 : currentChild.use) || matchedCurrentUids.has(currentChild.uid || "")) {
+      continue;
+    }
+    const currentGroup = remainingCurrentByUse.get(currentChild.use) || [];
+    currentGroup.push(currentChild);
+    remainingCurrentByUse.set(currentChild.use, currentGroup);
+  }
+  const uses = /* @__PURE__ */ new Set([...remainingCurrentByUse.keys(), ...remainingDesiredByUse.keys()]);
+  for (const use of uses) {
+    const currentGroup = remainingCurrentByUse.get(use) || [];
+    const desiredIndexes = remainingDesiredByUse.get(use) || [];
+    const shouldReuseByOrder = currentGroup.length > 1 || desiredIndexes.length > 1;
+    if (currentGroup.length > 0 && desiredIndexes.length > 0 && currentGroup.length !== desiredIndexes.length && shouldReuseByOrder) {
+      throw new import_errors.FlowSurfaceBadRequestError(
+        `flowSurfaces apply cannot safely match duplicate '${use}' nodes under '${parentUse}.${subKey}' without explicit uid or signature`
+      );
+    }
+    if (!shouldReuseByOrder) {
+      continue;
+    }
+    const reuseCount = Math.min(currentGroup.length, desiredIndexes.length);
+    for (let index = 0; index < reuseCount; index += 1) {
+      const currentChild = currentGroup[index];
+      const desiredIndex = desiredIndexes[index];
+      matchesByDesiredIndex.set(desiredIndex, currentChild);
+      if (currentChild == null ? void 0 : currentChild.uid) {
+        matchedCurrentUids.add(currentChild.uid);
+      }
+    }
+  }
+  return {
+    matchesByDesiredIndex,
+    matchedCurrentUids
+  };
+}
+function findExactArrayChildMatch(currentChildren, desiredChild, matchedCurrent) {
+  if (desiredChild.uid) {
+    return currentChildren.find((item) => (item == null ? void 0 : item.uid) === desiredChild.uid);
+  }
+  const desiredStrongSignature = getStrongNodeSignature(desiredChild);
+  if (desiredStrongSignature) {
+    return currentChildren.find(
+      (item) => !matchedCurrent.has(item.uid || "") && getStrongNodeSignature(item) === desiredStrongSignature
+    );
+  }
+  const desiredWeakSignature = getWeakNodeSignature(desiredChild);
+  if (desiredWeakSignature) {
+    return currentChildren.find(
+      (item) => !matchedCurrent.has(item.uid || "") && getWeakNodeSignature(item) === desiredWeakSignature
+    );
+  }
+  return void 0;
+}
+function getStrongNodeSignature(node) {
+  if (!(node == null ? void 0 : node.use)) {
+    return null;
+  }
+  const resourceInit = import_lodash.default.get(node, ["stepParams", "resourceSettings", "init"]);
+  if ((resourceInit == null ? void 0 : resourceInit.dataSourceKey) || (resourceInit == null ? void 0 : resourceInit.collectionName) || (resourceInit == null ? void 0 : resourceInit.associationName) || (resourceInit == null ? void 0 : resourceInit.associationPathName) || !import_lodash.default.isUndefined(resourceInit == null ? void 0 : resourceInit.sourceId)) {
+    return [
+      "resource",
+      node.use,
+      resourceInit.dataSourceKey || "",
+      resourceInit.collectionName || "",
+      resourceInit.associationName || "",
+      resourceInit.associationPathName || "",
+      import_lodash.default.isUndefined(resourceInit.sourceId) ? "" : String(resourceInit.sourceId)
+    ].join(":");
+  }
+  const fieldInit = import_lodash.default.get(node, ["stepParams", "fieldSettings", "init"]) || import_lodash.default.get(node, ["subModels", "field", "stepParams", "fieldSettings", "init"]);
+  if (fieldInit == null ? void 0 : fieldInit.fieldPath) {
+    return [
+      "field",
+      node.use,
+      fieldInit.dataSourceKey || "",
+      fieldInit.collectionName || "",
+      fieldInit.associationPathName || "",
+      fieldInit.fieldPath
+    ].join(":");
+  }
+  if (node.use === "TableActionsColumnModel") {
+    return "slot:table-actions-column";
+  }
+  return null;
+}
+function getWeakNodeSignature(node) {
+  if (!(node == null ? void 0 : node.use)) {
+    return null;
+  }
+  const title = import_lodash.default.get(node, ["stepParams", "pageTabSettings", "tab", "title"]) || import_lodash.default.get(node, ["stepParams", "buttonSettings", "general", "title"]) || import_lodash.default.get(node, ["props", "title"]);
+  if (typeof title === "string" && title.trim()) {
+    return ["title", node.use, title.trim()].join(":");
+  }
+  return null;
+}
+function isFieldWrapperNode(use) {
+  return (0, import_placement.isFieldWrapperUse)(use);
+}
+function isGridNode(use) {
+  return (0, import_placement.isGridUse)(use);
+}
+function isFieldContainer(parentUse, subKey) {
+  return (0, import_placement.isFieldContainerUse)(parentUse, subKey);
+}
+function isBlockContainer(parentUse, subKey) {
+  return (0, import_placement.isBlockContainerUse)(parentUse, subKey);
+}
+function isActionContainer(parentUse) {
+  return (0, import_placement.isActionContainerUse)(parentUse);
+}
+function extractResourceInit(node) {
+  return import_lodash.default.get(node, ["stepParams", "resourceSettings", "init"]);
+}
+function extractLayout(props) {
+  if (!props || !("rows" in props) && !("sizes" in props) && !("rowOrder" in props)) {
+    return null;
+  }
+  return {
+    rows: props.rows || {},
+    sizes: props.sizes || {},
+    rowOrder: props.rowOrder || Object.keys(props.rows || {})
+  };
+}
+function omitLayoutProps(props) {
+  if (!props) {
+    return props;
+  }
+  const next = import_lodash.default.omit(props, ["rows", "sizes", "rowOrder"]);
+  return Object.keys(next).length ? next : void 0;
+}
+function resolveLayoutRefs(layout, childClientKeyRefs) {
+  if (!layout) {
+    return layout;
+  }
+  return {
+    rows: Object.fromEntries(
+      Object.entries(layout.rows || {}).map(([rowId, cells]) => [
+        rowId,
+        import_lodash.default.castArray(cells).map(
+          (cell) => import_lodash.default.castArray(cell).map((itemUid) => childClientKeyRefs[itemUid] ?? itemUid)
+        )
+      ])
+    ),
+    sizes: layout.sizes || {},
+    rowOrder: layout.rowOrder || []
+  };
+}
+function hasRefValue(value) {
+  if (Array.isArray(value)) {
+    return value.some((item) => hasRefValue(item));
+  }
+  if (import_lodash.default.isPlainObject(value)) {
+    if (typeof value.ref === "string") {
+      return true;
+    }
+    return Object.values(value).some((item) => hasRefValue(item));
+  }
+  return false;
+}
+function buildAutoLayout(itemRefs) {
+  if (!itemRefs.length) {
+    return {
+      rows: {},
+      sizes: {},
+      rowOrder: []
+    };
+  }
+  return {
+    rows: Object.fromEntries(itemRefs.map((itemRef, index) => [`autoRow${index + 1}`, [[itemRef]]])),
+    sizes: Object.fromEntries(itemRefs.map((_2, index) => [`autoRow${index + 1}`, [24]])),
+    rowOrder: itemRefs.map((_2, index) => `autoRow${index + 1}`)
+  };
+}
+function didItemRefsChange(currentChildren, desiredRefs) {
+  if (currentChildren.length !== desiredRefs.length) {
+    return true;
+  }
+  return desiredRefs.some(
+    (item, index) => {
+      var _a;
+      return typeof item.uidRef !== "string" || ((_a = currentChildren[index]) == null ? void 0 : _a.uid) !== item.uidRef;
+    }
+  );
+}
+function nextOpId(state, prefix) {
+  state.seq += 1;
+  return `${prefix}_${state.seq}`;
+}
+function emitMoveTabOps(ops, desiredRefs) {
+  emitOrderedTabMoves(ops, desiredRefs, "moveTab");
+}
+function emitOrderedTabMoves(ops, desiredRefs, type) {
+  for (let index = desiredRefs.length - 2; index >= 0; index -= 1) {
+    ops.push({
+      type,
+      values: {
+        sourceUid: desiredRefs[index].uidRef,
+        targetUid: desiredRefs[index + 1].uidRef,
+        position: "before"
+      }
+    });
+  }
+}
+function bindClientKey(state, clientKey, uid) {
+  if (!clientKey || typeof uid !== "string") {
+    return;
+  }
+  state.clientKeyToUid[clientKey] = uid;
+}
+function syncPopupTabs(ops, state, popupPageRef, currentTabs, desiredTabs) {
+  const result = {
+    childClientKeyRefs: {},
+    finalItemRefs: [],
+    itemsChanged: false,
+    itemsSpecified: false
+  };
+  const tabMatchPlan = planArrayChildMatches(currentTabs, desiredTabs, popupPageRef.use, "tabs");
+  const desiredRefs = [];
+  for (const [desiredIndex, desiredTab] of desiredTabs.entries()) {
+    const currentMatch = tabMatchPlan.matchesByDesiredIndex.get(desiredIndex);
+    if (currentMatch) {
+      const currentRef = {
+        uidRef: currentMatch.uid,
+        use: currentMatch.use
+      };
+      bindClientKey(state, desiredTab.clientKey, currentMatch.uid);
+      if (desiredTab.clientKey) {
+        result.childClientKeyRefs[desiredTab.clientKey] = currentRef.uidRef;
+      }
+      desiredRefs.push(currentRef);
+      syncTabNode(ops, state, { uid: currentMatch.uid }, currentMatch, desiredTab);
+      continue;
+    }
+    const createdRef = createPopupTabNode(ops, state, popupPageRef, desiredTab);
+    if (desiredTab.clientKey) {
+      result.childClientKeyRefs[desiredTab.clientKey] = createdRef.uidRef;
+    }
+    desiredRefs.push(createdRef);
+  }
+  for (const currentTab of currentTabs) {
+    if (!tabMatchPlan.matchedCurrentUids.has(currentTab.uid)) {
+      ops.push({
+        type: "removePopupTab",
+        values: {
+          target: {
+            uid: currentTab.uid
+          }
+        }
+      });
+    }
+  }
+  emitOrderedTabMoves(ops, desiredRefs, "movePopupTab");
+  return result;
+}
+function createPopupTabNode(ops, state, popupPageRef, desiredNode) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const opId = nextOpId(state, "addPopupTab");
+  ops.push({
+    opId,
+    type: "addPopupTab",
+    values: {
+      target: {
+        uid: popupPageRef.uidRef
+      },
+      ...desiredNode.clientKey ? { clientKey: desiredNode.clientKey } : {},
+      title: ((_c = (_b = (_a = desiredNode == null ? void 0 : desiredNode.stepParams) == null ? void 0 : _a.pageTabSettings) == null ? void 0 : _b.tab) == null ? void 0 : _c.title) || ((_d = desiredNode == null ? void 0 : desiredNode.props) == null ? void 0 : _d.title) || ((_f = (_e = desiredNode == null ? void 0 : desiredNode.props) == null ? void 0 : _e.route) == null ? void 0 : _f.title) || "Untitled",
+      icon: ((_i = (_h = (_g = desiredNode == null ? void 0 : desiredNode.stepParams) == null ? void 0 : _g.pageTabSettings) == null ? void 0 : _h.tab) == null ? void 0 : _i.icon) || ((_j = desiredNode == null ? void 0 : desiredNode.props) == null ? void 0 : _j.icon),
+      documentTitle: (_m = (_l = (_k = desiredNode == null ? void 0 : desiredNode.stepParams) == null ? void 0 : _k.pageTabSettings) == null ? void 0 : _l.tab) == null ? void 0 : _m.documentTitle,
+      flowRegistry: desiredNode == null ? void 0 : desiredNode.flowRegistry
+    }
+  });
+  const ref = {
+    uidRef: makeOpRef(`${opId}.popupTabUid`),
+    use: "ChildPageTabModel",
+    sourceOpId: opId
+  };
+  syncCreatedNode(ops, state, ref, desiredNode);
+  return ref;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAutoLayout,
+  compileApplySpec
+});