@nocobase/plugin-flow-engine 2.1.0-alpha.15 → 2.1.0-alpha.17

package/dist/server/flow-surfaces/blueprint/compile-blocks.js

@@ -0,0 +1,717 @@
+/**
+ * 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 compile_blocks_exports = {};
+__export(compile_blocks_exports, {
+  collectReferencedBlockKeys: () => collectReferencedBlockKeys,
+  compileTabComposeValues: () => compileTabComposeValues
+});
+module.exports = __toCommonJS(compile_blocks_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_service_utils = require("../service-utils");
+var import_private_utils = require("./private-utils");
+const APPLY_BLUEPRINT_BLOCK_TYPE_ENUM = [
+  "table",
+  "createForm",
+  "editForm",
+  "details",
+  "filterForm",
+  "list",
+  "gridCard",
+  "markdown",
+  "iframe",
+  "chart",
+  "actionPanel",
+  "jsBlock"
+];
+const APPLY_BLUEPRINT_BLOCK_ALLOWED_KEYS = [
+  "key",
+  "type",
+  "title",
+  "collection",
+  "dataSourceKey",
+  "associationPathName",
+  "binding",
+  "associationField",
+  "resource",
+  "template",
+  "settings",
+  "fields",
+  "actions",
+  "recordActions",
+  "script",
+  "chart"
+];
+const APPLY_BLUEPRINT_FIELD_ALLOWED_KEYS = [
+  "key",
+  "field",
+  "associationPathName",
+  "renderer",
+  "type",
+  "label",
+  "target",
+  "settings",
+  "popup",
+  "script",
+  "chart"
+];
+const APPLY_BLUEPRINT_ACTION_ALLOWED_KEYS = ["key", "type", "title", "settings", "popup", "script", "chart"];
+const APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS = ["title", "mode", "template", "blocks", "layout"];
+const APPLY_BLUEPRINT_LAYOUT_ALLOWED_KEYS = ["rows"];
+const APPLY_BLUEPRINT_LAYOUT_CELL_ALLOWED_KEYS = ["key", "span"];
+const APPLY_BLUEPRINT_BLOCK_RESOURCE_ALLOWED_KEYS = [
+  "binding",
+  "dataSourceKey",
+  "collectionName",
+  "associationField",
+  "associationName",
+  "associationPathName",
+  "sourceId",
+  "filterByTk"
+];
+const APPLY_BLUEPRINT_BLOCK_RESOURCE_RAW_ONLY_KEYS = [
+  "associationName",
+  "associationPathName",
+  "sourceId",
+  "filterByTk"
+];
+const APPLY_BLUEPRINT_BLOCK_RESOURCE_SHORTHAND_KEYS = [
+  "collection",
+  "dataSourceKey",
+  "associationPathName",
+  "binding",
+  "associationField"
+];
+const APPLY_BLUEPRINT_RECORD_CAPABLE_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "details", "list", "gridCard"]);
+const APPLY_BLUEPRINT_AUTO_PROMOTED_RECORD_ACTION_TYPES = /* @__PURE__ */ new Set([
+  "view",
+  "edit",
+  "delete",
+  "updateRecord",
+  "duplicate"
+]);
+const APPLY_BLUEPRINT_BLOCK_TYPES = new Set(APPLY_BLUEPRINT_BLOCK_TYPE_ENUM);
+const APPLY_BLUEPRINT_ADD_CHILD_RECORD_ACTION_ERROR = "type 'addChild' must be authored under recordActions and is only valid when the live target catalog.recordActions exposes it for a tree collection table with treeTable enabled";
+function assertNoBlockLevelLayout(input, context) {
+  if (Object.prototype.hasOwnProperty.call(input, "layout")) {
+    (0, import_errors.throwBadRequest)(`${context}.layout is not supported; layout is only allowed on tabs[] and popup`);
+  }
+}
+function assertApplyBlueprintBlockType(type, context) {
+  if (!type) {
+    return;
+  }
+  if (type === "form") {
+    (0, import_errors.throwBadRequest)(`${context}.type 'form' is unsupported in applyBlueprint; use 'editForm' or 'createForm'`);
+  }
+  if (!APPLY_BLUEPRINT_BLOCK_TYPES.has(type)) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.type '${type}' is unsupported in applyBlueprint; supported types: ${APPLY_BLUEPRINT_BLOCK_TYPE_ENUM.join(
+        ", "
+      )}`
+    );
+  }
+}
+function normalizeEditPopupBlocks(input, context) {
+  input.forEach((block, index) => {
+    const blockType = (0, import_private_utils.readOptionalString)(block == null ? void 0 : block.type);
+    if (blockType === "form") {
+      (0, import_errors.throwBadRequest)(`${context}.blocks[${index}].type 'form' is unsupported in applyBlueprint; use 'editForm'`);
+    }
+  });
+  const editFormBlocks = input.filter((block) => (0, import_private_utils.readOptionalString)(block == null ? void 0 : block.type) === "editForm");
+  if (!editFormBlocks.length) {
+    (0, import_errors.throwBadRequest)(`${context} custom edit popup must contain exactly one editForm block`);
+  }
+  if (editFormBlocks.length > 1) {
+    (0, import_errors.throwBadRequest)(`${context} custom edit popup must contain exactly one editForm block`);
+  }
+  return input.map((block, index) => {
+    const blockType = (0, import_private_utils.readOptionalString)(block == null ? void 0 : block.type);
+    if (blockType !== "editForm") {
+      return block;
+    }
+    if (!import_lodash.default.isPlainObject(block)) {
+      return block;
+    }
+    if (!import_lodash.default.isUndefined(block.resource)) {
+      if (import_lodash.default.isPlainObject(block.resource)) {
+        const binding = "binding" in block.resource ? (0, import_private_utils.readOptionalString)(block.resource.binding) : void 0;
+        if (!binding) {
+          (0, import_errors.throwBadRequest)(
+            `${context}.blocks[${index}].resource must use binding='currentRecord' or be omitted in a custom edit popup`
+          );
+        }
+        if (binding !== "currentRecord") {
+          (0, import_errors.throwBadRequest)(
+            `${context}.blocks[${index}].resource.binding must be 'currentRecord' in a custom edit popup`
+          );
+        }
+      }
+      return block;
+    }
+    const shorthandBinding = (0, import_private_utils.readOptionalString)(block.binding);
+    if (!import_lodash.default.isUndefined(shorthandBinding)) {
+      if (shorthandBinding !== "currentRecord") {
+        (0, import_errors.throwBadRequest)(`${context}.blocks[${index}].binding must be 'currentRecord' in a custom edit popup`);
+      }
+      return block;
+    }
+    const hasRawShorthandResource = !import_lodash.default.isUndefined(block.collection) || !import_lodash.default.isUndefined(block.dataSourceKey) || !import_lodash.default.isUndefined(block.associationPathName) || !import_lodash.default.isUndefined(block.associationField);
+    if (hasRawShorthandResource) {
+      (0, import_errors.throwBadRequest)(
+        `${context}.blocks[${index}] must use binding='currentRecord' or omit resource entirely in a custom edit popup`
+      );
+    }
+    return {
+      ...block,
+      resource: {
+        binding: "currentRecord"
+      }
+    };
+  });
+}
+function readAssociationFieldFromSingleSegmentPath(value, context) {
+  const associationPathName = (0, import_private_utils.readOptionalString)(value);
+  if (!associationPathName) {
+    return void 0;
+  }
+  const segments = associationPathName.split(".").map((segment) => segment.trim()).filter(Boolean);
+  if (!segments.length) {
+    (0, import_errors.throwBadRequest)(`${context}.associationPathName must be a non-empty association field path`);
+  }
+  if (segments.length > 1) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.associationPathName '${associationPathName}' must be a single association field name when used with ${context}.binding; prefer ${context}.associationField for popup relation tables`
+    );
+  }
+  return segments[0];
+}
+function normalizeAssociatedRecordsBindingFromAssociationPath(input, context) {
+  const binding = (0, import_private_utils.readOptionalString)(input.binding);
+  const associationLeaf = readAssociationFieldFromSingleSegmentPath(input.associationPathName, context);
+  if (!binding || !associationLeaf) {
+    return null;
+  }
+  if (binding !== "currentRecord" && binding !== "associatedRecords") {
+    (0, import_errors.throwBadRequest)(
+      `${context} cannot mix ${context}.binding='${binding}' with ${context}.associationPathName; use associatedRecords + associationField on popup collection blocks`
+    );
+  }
+  const associationField = (0, import_private_utils.readOptionalString)(input.associationField);
+  if (associationField && associationField !== associationLeaf) {
+    (0, import_errors.throwBadRequest)(
+      `${context}.associationField '${associationField}' conflicts with ${context}.associationPathName '${(0, import_private_utils.readOptionalString)(
+        input.associationPathName
+      )}'`
+    );
+  }
+  return {
+    binding: "associatedRecords",
+    associationField: associationField || associationLeaf
+  };
+}
+function readApplyBlueprintActionType(input) {
+  if (typeof input === "string") {
+    return (0, import_private_utils.readString)(input);
+  }
+  if (import_lodash.default.isPlainObject(input)) {
+    return (0, import_private_utils.readOptionalString)(input.type);
+  }
+  return void 0;
+}
+function splitApplyBlueprintBlockActionsByScope(block, context) {
+  const rawActions = readOptionalItems(block.actions, `${context}.actions`);
+  const rawRecordActions = readOptionalItems(block.recordActions, `${context}.recordActions`);
+  const blockType = (0, import_private_utils.readOptionalString)(block.type);
+  if (!blockType || !APPLY_BLUEPRINT_RECORD_CAPABLE_BLOCK_TYPES.has(blockType)) {
+    return {
+      actions: rawActions,
+      recordActions: rawRecordActions
+    };
+  }
+  const promotedRecordActions = [];
+  const remainingActions = [];
+  rawActions.forEach((action, index) => {
+    const actionType = readApplyBlueprintActionType(action);
+    if (actionType === "addChild") {
+      (0, import_errors.throwBadRequest)(`${context}.actions[${index}] ${APPLY_BLUEPRINT_ADD_CHILD_RECORD_ACTION_ERROR}`);
+    }
+    if (actionType && APPLY_BLUEPRINT_AUTO_PROMOTED_RECORD_ACTION_TYPES.has(actionType)) {
+      promotedRecordActions.push(action);
+      return;
+    }
+    remainingActions.push(action);
+  });
+  return {
+    actions: remainingActions,
+    recordActions: [...rawRecordActions, ...promotedRecordActions]
+  };
+}
+function resolveAssetSettings(settings, spec, assets, context) {
+  const nextSettings = (0, import_private_utils.cloneOptionalPlainObject)(settings, `${context}.settings`) || {};
+  const mergeAsset = (bucket, assetKey) => {
+    const normalizedKey = (0, import_private_utils.readOptionalString)(assetKey);
+    if (!normalizedKey) {
+      return;
+    }
+    const registry = assets[bucket] || {};
+    const asset = registry[normalizedKey];
+    if (!import_lodash.default.isPlainObject(asset)) {
+      (0, import_errors.throwBadRequest)(`${context} ${bucket.slice(0, -1)} asset '${normalizedKey}' is not defined in assets.${bucket}`);
+    }
+    import_lodash.default.merge(nextSettings, import_lodash.default.cloneDeep(asset));
+  };
+  mergeAsset("charts", spec.chart);
+  mergeAsset("scripts", spec.script);
+  return nextSettings;
+}
+function readOptionalItems(value, context) {
+  return (0, import_private_utils.readOptionalArray)(value, context) || [];
+}
+function ensureOptionalTemplate(value, context) {
+  return (0, import_private_utils.cloneOptionalPlainObject)(value, context);
+}
+function resolvePopupTitleSettings(settings, title) {
+  if (!title) {
+    return settings;
+  }
+  const nextSettings = import_lodash.default.cloneDeep(settings || {});
+  if (import_lodash.default.isUndefined(import_lodash.default.get(nextSettings, ["openView", "title"]))) {
+    import_lodash.default.set(nextSettings, ["openView", "title"], title);
+  }
+  return nextSettings;
+}
+function normalizeBlockResourceObject(input, context) {
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, context, APPLY_BLUEPRINT_BLOCK_RESOURCE_ALLOWED_KEYS);
+  const hasBinding = Object.prototype.hasOwnProperty.call(input, "binding");
+  if (hasBinding) {
+    const normalizedAssociatedRecords = normalizeAssociatedRecordsBindingFromAssociationPath(input, context);
+    const mixedRawKeys = APPLY_BLUEPRINT_BLOCK_RESOURCE_RAW_ONLY_KEYS.filter(
+      (key) => Object.prototype.hasOwnProperty.call(input, key) && !(normalizedAssociatedRecords && key === "associationPathName")
+    );
+    if (mixedRawKeys.length) {
+      (0, import_errors.throwBadRequest)(
+        `${context} cannot mix binding with ${mixedRawKeys.map((key) => `${context}.${key}`).join(", ")}`
+      );
+    }
+    return (0, import_service_utils.buildDefinedPayload)({
+      binding: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.binding) || (0, import_private_utils.assertNonEmptyString)(input.binding, `${context}.binding`),
+      dataSourceKey: (0, import_private_utils.readOptionalString)(input.dataSourceKey),
+      collectionName: (0, import_private_utils.readOptionalString)(input.collectionName),
+      associationField: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.associationField) || (0, import_private_utils.readOptionalString)(input.associationField)
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "associationField")) {
+    (0, import_errors.throwBadRequest)(`${context}.associationField only works when ${context}.binding is provided`);
+  }
+  const collectionName = (0, import_private_utils.readOptionalString)(input.collectionName);
+  const normalized = (0, import_service_utils.buildDefinedPayload)({
+    dataSourceKey: (0, import_private_utils.readOptionalString)(input.dataSourceKey) || (collectionName ? "main" : void 0),
+    collectionName,
+    associationName: (0, import_private_utils.readOptionalString)(input.associationName),
+    associationPathName: (0, import_private_utils.readOptionalString)(input.associationPathName),
+    sourceId: input.sourceId,
+    filterByTk: input.filterByTk
+  });
+  if (!Object.keys(normalized).length) {
+    (0, import_errors.throwBadRequest)(`${context} cannot be empty`);
+  }
+  return normalized;
+}
+function buildBlockResource(block, context) {
+  if (!import_lodash.default.isUndefined(block.resource)) {
+    if (!import_lodash.default.isPlainObject(block.resource)) {
+      (0, import_errors.throwBadRequest)(`${context}.resource must be an object`);
+    }
+    const mixedShorthandKeys = APPLY_BLUEPRINT_BLOCK_RESOURCE_SHORTHAND_KEYS.filter(
+      (key) => Object.prototype.hasOwnProperty.call(block, key)
+    );
+    if (mixedShorthandKeys.length) {
+      (0, import_errors.throwBadRequest)(
+        `${context} cannot mix resource with ${mixedShorthandKeys.map((key) => `${context}.${key}`).join(", ")}`
+      );
+    }
+    return normalizeBlockResourceObject(block.resource, `${context}.resource`);
+  }
+  const binding = (0, import_private_utils.readOptionalString)(block.binding);
+  if (binding) {
+    const normalizedAssociatedRecords = normalizeAssociatedRecordsBindingFromAssociationPath(
+      block,
+      context
+    );
+    if (Object.prototype.hasOwnProperty.call(block, "associationPathName") && !normalizedAssociatedRecords) {
+      (0, import_errors.throwBadRequest)(`${context} cannot mix ${context}.binding with ${context}.associationPathName`);
+    }
+    return (0, import_service_utils.buildDefinedPayload)({
+      binding: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.binding) || binding,
+      dataSourceKey: (0, import_private_utils.readOptionalString)(block.dataSourceKey),
+      collectionName: (0, import_private_utils.readOptionalString)(block.collection),
+      associationField: (normalizedAssociatedRecords == null ? void 0 : normalizedAssociatedRecords.associationField) || (0, import_private_utils.readOptionalString)(block.associationField)
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(block, "associationField")) {
+    (0, import_errors.throwBadRequest)(`${context}.associationField only works when ${context}.binding is provided`);
+  }
+  const collectionName = (0, import_private_utils.readOptionalString)(block.collection);
+  if (!collectionName) {
+    return void 0;
+  }
+  return (0, import_service_utils.buildDefinedPayload)({
+    dataSourceKey: (0, import_private_utils.readOptionalString)(block.dataSourceKey) || "main",
+    collectionName,
+    associationPathName: (0, import_private_utils.readOptionalString)(block.associationPathName)
+  });
+}
+function ensureLayoutRows(layout, context) {
+  if (import_lodash.default.isUndefined(layout)) {
+    return void 0;
+  }
+  if (!import_lodash.default.isPlainObject(layout)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(layout, context, APPLY_BLUEPRINT_LAYOUT_ALLOWED_KEYS);
+  if (!Array.isArray(layout.rows) || !layout.rows.length) {
+    (0, import_errors.throwBadRequest)(`${context}.rows must be a non-empty array`);
+  }
+  return layout.rows.map((row, rowIndex) => {
+    if (!Array.isArray(row) || !row.length) {
+      (0, import_errors.throwBadRequest)(`${context}.rows[${rowIndex}] must be a non-empty array`);
+    }
+    row.forEach((item, itemIndex) => {
+      if (typeof item === "string") {
+        return;
+      }
+      if (!import_lodash.default.isPlainObject(item)) {
+        (0, import_errors.throwBadRequest)(`${context}.rows[${rowIndex}][${itemIndex}] must be a string or object`);
+      }
+      (0, import_private_utils.assertOnlyAllowedKeys)(
+        item,
+        `${context}.rows[${rowIndex}][${itemIndex}]`,
+        APPLY_BLUEPRINT_LAYOUT_CELL_ALLOWED_KEYS
+      );
+    });
+    return row;
+  });
+}
+function autoLayoutFromBlockKeys(blockKeys) {
+  return {
+    rows: blockKeys.map((key) => [key])
+  };
+}
+function collectReferencedBlockKeys(layout, context) {
+  const referenced = /* @__PURE__ */ new Set();
+  const rows = ensureLayoutRows(layout, context) || [];
+  rows.forEach((row, rowIndex) => {
+    row.forEach((cell, itemIndex) => {
+      if (typeof cell === "string") {
+        const key2 = (0, import_private_utils.readString)(cell);
+        if (key2) {
+          referenced.add(key2);
+        }
+        return;
+      }
+      const key = (0, import_private_utils.assertNonEmptyString)(cell.key, `${context}.rows[${rowIndex}][${itemIndex}].key`);
+      if (key) {
+        referenced.add(key);
+      }
+    });
+  });
+  return referenced;
+}
+function compileLayout(layout, blockKeysByLocalKey, context) {
+  const rows = ensureLayoutRows(layout, context);
+  if (!rows) {
+    return void 0;
+  }
+  return {
+    rows: rows.map((row, rowIndex) => {
+      return row.map((item, itemIndex) => {
+        if (typeof item === "string") {
+          const itemKey = (0, import_private_utils.readString)(item);
+          const resolved2 = blockKeysByLocalKey.get(itemKey) || [...blockKeysByLocalKey.values()].find((value) => value === itemKey);
+          if (!resolved2) {
+            (0, import_errors.throwBadRequest)(`${context}.rows[${rowIndex}][${itemIndex}] references unknown block '${item}'`);
+          }
+          return resolved2;
+        }
+        const rawKey = (0, import_private_utils.assertNonEmptyString)(item.key, `${context}.rows[${rowIndex}][${itemIndex}].key`);
+        const resolved = blockKeysByLocalKey.get(rawKey) || [...blockKeysByLocalKey.values()].find((value) => value === rawKey) || rawKey;
+        return (0, import_service_utils.buildDefinedPayload)({
+          key: resolved,
+          span: import_lodash.default.isUndefined(item.span) ? void 0 : import_lodash.default.isNumber(item.span) ? item.span : (0, import_errors.throwBadRequest)(`${context}.rows[${rowIndex}][${itemIndex}].span must be a number`)
+        });
+      });
+    })
+  };
+}
+function compilePopup(popup, scopePrefix, assets, context, options = {}) {
+  if (import_lodash.default.isUndefined(popup)) {
+    return {};
+  }
+  if (!import_lodash.default.isPlainObject(popup)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(popup, context, APPLY_BLUEPRINT_POPUP_ALLOWED_KEYS);
+  const popupTitle = (0, import_private_utils.readOptionalString)(popup.title);
+  const template = ensureOptionalTemplate(popup.template, `${context}.template`);
+  if (template) {
+    return {
+      popup: {
+        template
+      },
+      popupTitle
+    };
+  }
+  const rawPopupBlocks = readOptionalItems(popup.blocks, `${context}.blocks`);
+  const popupBlocks = options.ownerActionType === "edit" && rawPopupBlocks.length ? normalizeEditPopupBlocks(rawPopupBlocks, context) : rawPopupBlocks;
+  const compiledBlocks = popupBlocks.length ? compileBlocks(
+    popupBlocks,
+    scopePrefix,
+    assets,
+    `${context}.blocks`,
+    collectReferencedBlockKeys(popup.layout, `${context}.layout`)
+  ) : { blocks: [], blockKeysByLocalKey: /* @__PURE__ */ new Map() };
+  const layout = popupBlocks.length || popup.layout ? compileLayout(
+    popup.layout || autoLayoutFromBlockKeys(compiledBlocks.blocks.map((block) => block.key)),
+    compiledBlocks.blockKeysByLocalKey,
+    `${context}.layout`
+  ) : void 0;
+  const popupMode = (0, import_private_utils.readOptionalString)(popup.mode);
+  if (popupMode && popupMode !== "replace" && popupMode !== "append") {
+    (0, import_errors.throwBadRequest)(`${context}.mode must be 'replace' or 'append'`);
+  }
+  const compiledPopup = (0, import_service_utils.buildDefinedPayload)({
+    mode: popupMode || (popupBlocks.length || template || layout ? "replace" : void 0),
+    template,
+    blocks: compiledBlocks.blocks.length ? compiledBlocks.blocks : void 0,
+    layout
+  });
+  return {
+    popup: Object.keys(compiledPopup).length ? compiledPopup : {},
+    popupTitle
+  };
+}
+function resolveTargetBlockKey(value, localBlockKeys, context) {
+  if (import_lodash.default.isUndefined(value) || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const normalized = (0, import_private_utils.readString)(value);
+    return localBlockKeys.get(normalized) || normalized;
+  }
+  (0, import_errors.throwBadRequest)(`${context} must be a string block key`);
+}
+function compileField(input, index, scopePrefix, assets, localBlockKeys, context) {
+  if (typeof input === "string") {
+    const fieldPath2 = (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
+    return {
+      key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, fieldPath2), `${context}[${index}]`),
+      fieldPath: fieldPath2
+    };
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] must be a string or object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, `${context}[${index}]`, APPLY_BLUEPRINT_FIELD_ALLOWED_KEYS);
+  const fieldPath = (0, import_private_utils.readOptionalString)(input.field);
+  const syntheticType = (0, import_private_utils.readOptionalString)(input.type);
+  if (!fieldPath && !syntheticType) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] requires field or type`);
+  }
+  if (fieldPath && syntheticType) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] cannot mix field with synthetic type`);
+  }
+  const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(
+    input.key,
+    fieldPath || (syntheticType ? `${syntheticType}_${index + 1}` : `field_${index + 1}`),
+    `${context}[${index}].key`
+  );
+  const key = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`);
+  let settings = resolveAssetSettings(input.settings, input, assets, `${context}[${index}]`);
+  if ((0, import_private_utils.readOptionalString)(input.label) && import_lodash.default.isUndefined(settings.label)) {
+    settings.label = (0, import_private_utils.readOptionalString)(input.label);
+  }
+  const popupResult = compilePopup(input.popup, `${key}.popup`, assets, `${context}[${index}].popup`);
+  settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
+  return (0, import_service_utils.buildDefinedPayload)({
+    key,
+    fieldPath,
+    associationPathName: (0, import_private_utils.readOptionalString)(input.associationPathName),
+    renderer: (0, import_private_utils.readOptionalString)(input.renderer),
+    type: syntheticType,
+    target: resolveTargetBlockKey(input.target, localBlockKeys, `${context}[${index}].target`),
+    settings: Object.keys(settings).length ? settings : void 0,
+    popup: popupResult.popup
+  });
+}
+function compileAction(input, index, scopePrefix, assets, context) {
+  if (typeof input === "string") {
+    const type2 = (0, import_private_utils.assertNonEmptyString)(input, `${context}[${index}]`);
+    return {
+      key: (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, `${type2}_${index + 1}`), `${context}[${index}]`),
+      type: type2
+    };
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context}[${index}] must be a string or object`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, `${context}[${index}]`, APPLY_BLUEPRINT_ACTION_ALLOWED_KEYS);
+  const type = (0, import_private_utils.assertNonEmptyString)(input.type, `${context}[${index}].type`);
+  const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(input.key, `${type}_${index + 1}`, `${context}[${index}].key`);
+  const key = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`);
+  let settings = resolveAssetSettings(input.settings, input, assets, `${context}[${index}]`);
+  if ((0, import_private_utils.readOptionalString)(input.title) && import_lodash.default.isUndefined(settings.title)) {
+    settings.title = (0, import_private_utils.readOptionalString)(input.title);
+  }
+  const popupResult = compilePopup(input.popup, `${key}.popup`, assets, `${context}[${index}].popup`, {
+    ownerActionType: type
+  });
+  settings = resolvePopupTitleSettings(settings, popupResult.popupTitle);
+  return (0, import_service_utils.buildDefinedPayload)({
+    key,
+    type,
+    settings: Object.keys(settings).length ? settings : void 0,
+    popup: popupResult.popup
+  });
+}
+function compileBlocks(input, scopePrefix, assets, context, requiredExplicitBlockKeys = /* @__PURE__ */ new Set()) {
+  const blockKeysByLocalKey = /* @__PURE__ */ new Map();
+  const referencedBlockKeys = new Set(requiredExplicitBlockKeys);
+  const rawBlocks = import_lodash.default.castArray(input || []);
+  rawBlocks.forEach((block, index) => {
+    if (!import_lodash.default.isPlainObject(block)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] must be an object`);
+    }
+    const fields = readOptionalItems(block == null ? void 0 : block.fields, `${context}[${index}].fields`);
+    fields.forEach((field, fieldIndex) => {
+      if (typeof (field == null ? void 0 : field.target) !== "string" || !field.target.trim()) {
+        return;
+      }
+      referencedBlockKeys.add(
+        (0, import_service_utils.normalizeFlowSurfaceComposeKey)(field.target, `${context}[${index}].fields[${fieldIndex}].target`)
+      );
+    });
+  });
+  rawBlocks.forEach((block, index) => {
+    if (!import_lodash.default.isPlainObject(block)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] must be an object`);
+    }
+    assertNoBlockLevelLayout(block, `${context}[${index}]`);
+    (0, import_private_utils.assertOnlyAllowedKeys)(block, `${context}[${index}]`, APPLY_BLUEPRINT_BLOCK_ALLOWED_KEYS);
+    assertApplyBlueprintBlockType((0, import_private_utils.readOptionalString)(block.type), `${context}[${index}]`);
+    const explicitKey = (0, import_private_utils.readString)(block.key);
+    const fallback = block.type ? `${block.type}_${index + 1}` : `block_${index + 1}`;
+    const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(block.key, fallback, `${context}[${index}].key`);
+    if (!explicitKey && referencedBlockKeys.has(localKey)) {
+      (0, import_errors.throwBadRequest)(
+        `${context}[${index}] must provide key explicitly because it is referenced by layout or field.target`
+      );
+    }
+    if (blockKeysByLocalKey.has(localKey)) {
+      (0, import_errors.throwBadRequest)(`${context}[${index}] key '${localKey}' is duplicated`);
+    }
+    const key = (0, import_service_utils.normalizeFlowSurfaceComposeKey)((0, import_private_utils.buildScopedKey)(scopePrefix, localKey), `${context}[${index}]`);
+    blockKeysByLocalKey.set(localKey, key);
+  });
+  const blocks = rawBlocks.map((block, index) => {
+    const blockContext = `${context}[${index}]`;
+    const localKey = (0, import_private_utils.normalizeBlueprintLocalKey)(
+      block.key,
+      block.type ? `${block.type}_${index + 1}` : `block_${index + 1}`,
+      `${blockContext}.key`
+    );
+    const key = blockKeysByLocalKey.get(localKey);
+    if (!key) {
+      (0, import_errors.throwBadRequest)(`${blockContext} key '${localKey}' is missing after block key compilation`);
+    }
+    const settings = resolveAssetSettings(block.settings, block, assets, blockContext);
+    if ((0, import_private_utils.readOptionalString)(block.title) && import_lodash.default.isUndefined(settings.title)) {
+      settings.title = (0, import_private_utils.readOptionalString)(block.title);
+    }
+    const template = ensureOptionalTemplate(block.template, `${blockContext}.template`);
+    const fields = readOptionalItems(block.fields, `${blockContext}.fields`);
+    const { actions, recordActions } = splitApplyBlueprintBlockActionsByScope(block, blockContext);
+    return (0, import_service_utils.buildDefinedPayload)({
+      key,
+      type: (0, import_private_utils.readOptionalString)(block.type),
+      resource: buildBlockResource(block, blockContext),
+      template,
+      settings: Object.keys(settings).length ? settings : void 0,
+      fields: fields.map(
+        (field, fieldIndex) => compileField(field, fieldIndex, key, assets, blockKeysByLocalKey, `${blockContext}.fields`)
+      ),
+      actions: actions.map(
+        (action, actionIndex) => compileAction(action, actionIndex, key, assets, `${blockContext}.actions`)
+      ),
+      recordActions: recordActions.map(
+        (action, actionIndex) => compileAction(action, actionIndex, key, assets, `${blockContext}.recordActions`)
+      )
+    });
+  });
+  return {
+    blocks,
+    blockKeysByLocalKey
+  };
+}
+function compileTabComposeValues(tab, document, tabIndex, options) {
+  const tabPublicPath = (0, import_private_utils.buildApplyBlueprintTabPublicPath)(tabIndex);
+  const blocksPath = `${tabPublicPath}.blocks`;
+  const layoutPath = `${tabPublicPath}.layout`;
+  const compiledBlocks = compileBlocks(
+    tab.blocks,
+    tab.key,
+    document.assets,
+    blocksPath,
+    collectReferencedBlockKeys(tab.layout, layoutPath)
+  );
+  const layout = compileLayout(
+    tab.layout || autoLayoutFromBlockKeys(compiledBlocks.blocks.map((block) => block.key)),
+    compiledBlocks.blockKeysByLocalKey,
+    layoutPath
+  );
+  return (0, import_service_utils.buildDefinedPayload)({
+    mode: options.mode,
+    blocks: compiledBlocks.blocks,
+    layout
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectReferencedBlockKeys,
+  compileTabComposeValues
+});