@nocobase/plugin-flow-engine 2.1.0-beta.14 → 2.1.0-beta.16

package/dist/server/flow-surfaces/blueprint/normalize-document.js

@@ -0,0 +1,416 @@
+/**
+ * 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 normalize_document_exports = {};
+__export(normalize_document_exports, {
+  prepareFlowSurfaceApplyBlueprintDocument: () => prepareFlowSurfaceApplyBlueprintDocument
+});
+module.exports = __toCommonJS(normalize_document_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_errors2 = require("../reaction/errors");
+var import_service_utils = require("../service-utils");
+var import_private_utils = require("./private-utils");
+const APPLY_BLUEPRINT_REACTION_ITEM_ALLOWED_KEYS = ["type", "target", "rules", "expectedFingerprint"];
+const APPLY_BLUEPRINT_REACTION_TYPES = [
+  "setFieldValueRules",
+  "setBlockLinkageRules",
+  "setFieldLinkageRules",
+  "setActionLinkageRules"
+];
+const APPLY_BLUEPRINT_REACTION_TYPE_SET = new Set(APPLY_BLUEPRINT_REACTION_TYPES);
+const APPLY_BLUEPRINT_DEFAULT_COLLECTION_ALLOWED_KEYS = ["fieldGroups", "popups"];
+const APPLY_BLUEPRINT_DEFAULT_FIELD_GROUP_ALLOWED_KEYS = ["key", "title", "fields"];
+const APPLY_BLUEPRINT_DEFAULT_POPUPS_ALLOWED_KEYS = ["view", "addNew", "edit", "associations"];
+const APPLY_BLUEPRINT_DEFAULT_POPUP_ACTION_ALLOWED_KEYS = ["name", "description"];
+const APPLY_BLUEPRINT_DEFAULT_POPUP_ASSOCIATION_ALLOWED_KEYS = ["view", "addNew", "edit"];
+const APPLY_BLUEPRINT_DEFAULT_POPUP_ACTIONS = ["view", "addNew", "edit"];
+function assertSupportedApplyBlueprintTopLevelKeys(input) {
+  const allowedKeys = ["version", "mode", "target", "navigation", "page", "defaults", "assets", "tabs", "reaction"];
+  const unsupportedKeys = Object.keys(input).filter((key) => !allowedKeys.includes(key));
+  if (!unsupportedKeys.length) {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(
+    `flowSurfaces applyBlueprint only accepts top-level keys ${allowedKeys.join(
+      ", "
+    )}; unsupported keys: ${unsupportedKeys.join(", ")}`
+  );
+}
+function assertSupportedApplyBlueprintTarget(input) {
+  if (import_lodash.default.isUndefined(input.target)) {
+    return;
+  }
+  (0, import_private_utils.assertPlainObject)(input.target, "flowSurfaces applyBlueprint target");
+  if (import_lodash.default.isPlainObject(input.target) && typeof input.target.mode !== "undefined") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint target only accepts pageSchemaUid; use top-level mode instead`);
+  }
+  (0, import_private_utils.assertOnlyAllowedKeys)(input.target, "flowSurfaces applyBlueprint target", ["pageSchemaUid"]);
+}
+function normalizePage(input) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  (0, import_private_utils.assertPlainObject)(input, "flowSurfaces applyBlueprint page");
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, "flowSurfaces applyBlueprint page", [
+    "title",
+    "icon",
+    "documentTitle",
+    "enableHeader",
+    "enableTabs",
+    "displayTitle"
+  ]);
+  const normalized = (0, import_service_utils.buildDefinedPayload)({
+    title: (0, import_private_utils.readOptionalString)(input.title),
+    icon: (0, import_private_utils.readOptionalString)(input.icon),
+    documentTitle: (0, import_private_utils.readOptionalString)(input.documentTitle),
+    enableHeader: (0, import_private_utils.readBoolean)(input.enableHeader, "flowSurfaces applyBlueprint page.enableHeader"),
+    enableTabs: (0, import_private_utils.readBoolean)(input.enableTabs, "flowSurfaces applyBlueprint page.enableTabs"),
+    displayTitle: (0, import_private_utils.readBoolean)(input.displayTitle, "flowSurfaces applyBlueprint page.displayTitle")
+  });
+  return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizeNavigation(input) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  (0, import_private_utils.assertPlainObject)(input, "flowSurfaces applyBlueprint navigation");
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, "flowSurfaces applyBlueprint navigation", ["group", "item"]);
+  const normalized = (0, import_service_utils.buildDefinedPayload)({
+    group: import_lodash.default.isUndefined(input.group) ? void 0 : (() => {
+      (0, import_private_utils.assertPlainObject)(input.group, "flowSurfaces applyBlueprint navigation.group");
+      (0, import_private_utils.assertOnlyAllowedKeys)(input.group, "flowSurfaces applyBlueprint navigation.group", [
+        "routeId",
+        "title",
+        "icon",
+        "tooltip",
+        "hideInMenu"
+      ]);
+      const routeId = input.group.routeId;
+      if (!import_lodash.default.isUndefined(routeId) && !import_lodash.default.isString(routeId) && !import_lodash.default.isNumber(routeId)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint navigation.group.routeId must be a string or integer`);
+      }
+      if (!import_lodash.default.isUndefined(routeId) && (0, import_private_utils.readString)(input.group.title)) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint navigation.group cannot mix routeId with title`);
+      }
+      const routeMetadataKeys = import_private_utils.APPLY_BLUEPRINT_CREATE_MENU_GROUP_METADATA_KEYS.filter(
+        (key) => !import_lodash.default.isUndefined(input.group[key])
+      );
+      if (!import_lodash.default.isUndefined(routeId) && routeMetadataKeys.length) {
+        (0, import_errors.throwBadRequest)(
+          `flowSurfaces applyBlueprint navigation.group.routeId cannot mix with ${routeMetadataKeys.map((key) => `navigation.group.${key}`).join(
+            ", "
+          )}; applyBlueprint create mode does not update existing menu-group metadata. Use flowSurfaces:updateMenu separately if needed`
+        );
+      }
+      const normalized2 = (0, import_service_utils.buildDefinedPayload)({
+        routeId: import_lodash.default.isUndefined(routeId) ? void 0 : routeId,
+        title: (0, import_private_utils.readOptionalString)(input.group.title),
+        icon: (0, import_private_utils.readOptionalString)(input.group.icon),
+        tooltip: (0, import_private_utils.readOptionalString)(input.group.tooltip),
+        hideInMenu: (0, import_private_utils.readBoolean)(input.group.hideInMenu, "flowSurfaces applyBlueprint navigation.group.hideInMenu")
+      });
+      if (import_lodash.default.isUndefined(normalized2.routeId) && !normalized2.title) {
+        (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint navigation.group requires routeId or title`);
+      }
+      return normalized2;
+    })(),
+    item: import_lodash.default.isUndefined(input.item) ? void 0 : (() => {
+      (0, import_private_utils.assertPlainObject)(input.item, "flowSurfaces applyBlueprint navigation.item");
+      (0, import_private_utils.assertOnlyAllowedKeys)(input.item, "flowSurfaces applyBlueprint navigation.item", [
+        "title",
+        "icon",
+        "tooltip",
+        "hideInMenu"
+      ]);
+      return (0, import_service_utils.buildDefinedPayload)({
+        title: (0, import_private_utils.readOptionalString)(input.item.title),
+        icon: (0, import_private_utils.readOptionalString)(input.item.icon),
+        tooltip: (0, import_private_utils.readOptionalString)(input.item.tooltip),
+        hideInMenu: (0, import_private_utils.readBoolean)(input.item.hideInMenu, "flowSurfaces applyBlueprint navigation.item.hideInMenu")
+      });
+    })()
+  });
+  return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizeDefaultFieldGroups(input, context) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  if (!Array.isArray(input) || !input.length) {
+    (0, import_errors.throwBadRequest)(`${context} must be a non-empty array`);
+  }
+  return input.map((group, groupIndex) => {
+    const groupContext = `${context}[${groupIndex}]`;
+    (0, import_private_utils.assertPlainObject)(group, groupContext);
+    (0, import_private_utils.assertOnlyAllowedKeys)(group, groupContext, APPLY_BLUEPRINT_DEFAULT_FIELD_GROUP_ALLOWED_KEYS);
+    if (!Array.isArray(group.fields) || !group.fields.length) {
+      (0, import_errors.throwBadRequest)(`${groupContext}.fields must be a non-empty array`);
+    }
+    return (0, import_service_utils.buildDefinedPayload)({
+      key: (0, import_private_utils.readOptionalString)(group.key),
+      title: (0, import_private_utils.assertNonEmptyString)(group.title, `${groupContext}.title`),
+      fields: group.fields.map(
+        (field, fieldIndex) => (0, import_private_utils.assertNonEmptyString)(field, `${groupContext}.fields[${fieldIndex}]`)
+      )
+    });
+  });
+}
+function normalizeDefaultPopupName(input, context) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  (0, import_private_utils.assertPlainObject)(input, context);
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, context, APPLY_BLUEPRINT_DEFAULT_POPUP_ACTION_ALLOWED_KEYS);
+  return {
+    name: (0, import_private_utils.assertNonEmptyString)(input.name, `${context}.name`),
+    description: (0, import_private_utils.assertNonEmptyString)(input.description, `${context}.description`)
+  };
+}
+function normalizeDefaultPopupActionMap(input, context, allowedKeys) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  (0, import_private_utils.assertPlainObject)(input, context);
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, context, [...allowedKeys]);
+  const normalized = (0, import_service_utils.buildDefinedPayload)(
+    Object.fromEntries(
+      APPLY_BLUEPRINT_DEFAULT_POPUP_ACTIONS.map((action) => [
+        action,
+        normalizeDefaultPopupName(input[action], `${context}.${action}`)
+      ])
+    )
+  );
+  return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizeDefaultPopups(input, context) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  const actionMap = normalizeDefaultPopupActionMap(input, context, APPLY_BLUEPRINT_DEFAULT_POPUPS_ALLOWED_KEYS);
+  const associationsInput = input.associations;
+  const associations = import_lodash.default.isUndefined(associationsInput) ? void 0 : (() => {
+    (0, import_private_utils.assertPlainObject)(associationsInput, `${context}.associations`);
+    return Object.fromEntries(
+      Object.entries(associationsInput).flatMap(([field, value]) => {
+        const associationField = (0, import_private_utils.assertNonEmptyString)(field, `${context}.associations key`);
+        const normalizedValue = normalizeDefaultPopupActionMap(
+          value,
+          `${context}.associations.${associationField}`,
+          APPLY_BLUEPRINT_DEFAULT_POPUP_ASSOCIATION_ALLOWED_KEYS
+        );
+        return normalizedValue ? [[associationField, normalizedValue]] : [];
+      })
+    );
+  })();
+  const normalized = (0, import_service_utils.buildDefinedPayload)({
+    ...actionMap,
+    associations: associations && Object.keys(associations).length ? associations : void 0
+  });
+  return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizeDefaultCollection(input, context) {
+  (0, import_private_utils.assertPlainObject)(input, context);
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, context, APPLY_BLUEPRINT_DEFAULT_COLLECTION_ALLOWED_KEYS);
+  return (0, import_service_utils.buildDefinedPayload)({
+    fieldGroups: normalizeDefaultFieldGroups(input.fieldGroups, `${context}.fieldGroups`),
+    popups: normalizeDefaultPopups(input.popups, `${context}.popups`)
+  });
+}
+function normalizeDefaults(input) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  (0, import_private_utils.assertPlainObject)(input, "flowSurfaces applyBlueprint defaults");
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, "flowSurfaces applyBlueprint defaults", ["collections"]);
+  if (import_lodash.default.isUndefined(input.collections)) {
+    return {};
+  }
+  (0, import_private_utils.assertPlainObject)(input.collections, "flowSurfaces applyBlueprint defaults.collections");
+  return {
+    collections: Object.fromEntries(
+      Object.entries(input.collections).map(([collectionName, collectionDefaults]) => {
+        const normalizedCollectionName = (0, import_private_utils.assertNonEmptyString)(
+          collectionName,
+          "flowSurfaces applyBlueprint defaults.collections key"
+        );
+        return [
+          normalizedCollectionName,
+          normalizeDefaultCollection(
+            collectionDefaults,
+            `flowSurfaces applyBlueprint defaults.collections.${normalizedCollectionName}`
+          )
+        ];
+      })
+    )
+  };
+}
+function normalizeTabs(input) {
+  const seenTabKeys = /* @__PURE__ */ new Set();
+  return input.map((tab, index) => {
+    (0, import_private_utils.assertPlainObject)(tab, `flowSurfaces applyBlueprint tabs[${index}]`);
+    (0, import_private_utils.assertOnlyAllowedKeys)(tab, `flowSurfaces applyBlueprint tabs[${index}]`, [
+      "key",
+      "title",
+      "icon",
+      "documentTitle",
+      "blocks",
+      "layout"
+    ]);
+    if (!Array.isArray(tab.blocks) || !tab.blocks.length) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint tabs[${index}].blocks must be a non-empty array`);
+    }
+    const explicitKey = (0, import_private_utils.readString)(tab.key);
+    return {
+      key: (0, import_private_utils.normalizeTabLocalKey)(tab.key, (0, import_private_utils.readString)(tab.title) || `tab_${index + 1}`, index, seenTabKeys, {
+        explicit: !!explicitKey
+      }),
+      title: (0, import_private_utils.readOptionalString)(tab.title),
+      icon: (0, import_private_utils.readOptionalString)(tab.icon),
+      documentTitle: (0, import_private_utils.readOptionalString)(tab.documentTitle),
+      blocks: import_lodash.default.cloneDeep(tab.blocks),
+      layout: (0, import_private_utils.cloneOptionalPlainObject)(tab.layout, `flowSurfaces applyBlueprint tabs[${index}].layout`)
+    };
+  });
+}
+function normalizeReaction(input) {
+  if (import_lodash.default.isUndefined(input)) {
+    return void 0;
+  }
+  (0, import_private_utils.assertPlainObject)(input, "flowSurfaces applyBlueprint reaction");
+  (0, import_private_utils.assertOnlyAllowedKeys)(input, "flowSurfaces applyBlueprint reaction", ["items"]);
+  if (!Array.isArray(input.items)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint reaction.items must be an array`);
+  }
+  const seenSlots = /* @__PURE__ */ new Set();
+  return {
+    items: input.items.map((item, index) => {
+      const context = `flowSurfaces applyBlueprint reaction.items[${index}]`;
+      (0, import_private_utils.assertPlainObject)(item, context);
+      (0, import_private_utils.assertOnlyAllowedKeys)(item, context, [...APPLY_BLUEPRINT_REACTION_ITEM_ALLOWED_KEYS]);
+      const type = (0, import_private_utils.assertNonEmptyString)(item.type, `${context}.type`);
+      if (!APPLY_BLUEPRINT_REACTION_TYPE_SET.has(type)) {
+        (0, import_errors.throwBadRequest)(
+          `${context}.type '${type}' is unsupported; supported types: ${APPLY_BLUEPRINT_REACTION_TYPES.join(", ")}`
+        );
+      }
+      const target = (0, import_service_utils.normalizeFlowSurfaceComposeKey)(
+        (0, import_private_utils.assertNonEmptyString)(item.target, `${context}.target`),
+        `${context}.target`
+      );
+      if (!Array.isArray(item.rules)) {
+        (0, import_errors.throwBadRequest)(`${context}.rules must be an array`);
+      }
+      const slotKey = `${type}::${target}`;
+      if (seenSlots.has(slotKey)) {
+        (0, import_errors.throwBadRequest)(
+          `${context} duplicates reaction slot '${type}' for target '${target}'`,
+          import_errors2.FLOW_SURFACE_REACTION_DUPLICATE_SLOT
+        );
+      }
+      seenSlots.add(slotKey);
+      return (0, import_service_utils.buildDefinedPayload)({
+        type,
+        target,
+        rules: import_lodash.default.cloneDeep(item.rules),
+        expectedFingerprint: import_lodash.default.isUndefined(item.expectedFingerprint) ? void 0 : (0, import_private_utils.assertNonEmptyString)(item.expectedFingerprint, `${context}.expectedFingerprint`)
+      });
+    })
+  };
+}
+function prepareFlowSurfaceApplyBlueprintDocument(input) {
+  var _a, _b;
+  (0, import_private_utils.assertPlainObject)(input, "flowSurfaces applyBlueprint payload");
+  assertSupportedApplyBlueprintTopLevelKeys(input);
+  assertSupportedApplyBlueprintTarget(input);
+  const version = import_lodash.default.isUndefined(input.version) ? "1" : (0, import_private_utils.assertNonEmptyString)(input.version, "flowSurfaces applyBlueprint version");
+  if (version !== "1") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint version '${version}' is not supported`);
+  }
+  const mode = (0, import_private_utils.assertNonEmptyString)(input.mode, "flowSurfaces applyBlueprint mode");
+  if (mode !== "create" && mode !== "replace") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint mode must be 'create' or 'replace'`);
+  }
+  if (!Array.isArray(input.tabs) || !input.tabs.length) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint tabs must be a non-empty array`);
+  }
+  const page = normalizePage(input.page);
+  const navigation = normalizeNavigation(input.navigation);
+  const defaults = normalizeDefaults(input.defaults);
+  if (mode === "create" && !import_lodash.default.isUndefined(input.target)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint create mode does not accept target`);
+  }
+  if (mode === "replace" && !import_lodash.default.isPlainObject(input.target)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint replace mode requires target.pageSchemaUid`);
+  }
+  if (mode === "replace" && navigation) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint replace mode does not accept navigation`);
+  }
+  const target = mode === "replace" ? {
+    pageSchemaUid: (0, import_private_utils.assertNonEmptyString)(
+      input.target.pageSchemaUid,
+      "flowSurfaces applyBlueprint target.pageSchemaUid"
+    )
+  } : void 0;
+  if (!import_lodash.default.isUndefined(input.assets)) {
+    (0, import_private_utils.assertPlainObject)(input.assets, "flowSurfaces applyBlueprint assets");
+    (0, import_private_utils.assertOnlyAllowedKeys)(input.assets, "flowSurfaces applyBlueprint assets", ["scripts", "charts"]);
+  }
+  const assets = {
+    scripts: (0, import_private_utils.normalizeAssetRegistry)((_a = input.assets) == null ? void 0 : _a.scripts, "flowSurfaces applyBlueprint assets.scripts"),
+    charts: (0, import_private_utils.normalizeAssetRegistry)((_b = input.assets) == null ? void 0 : _b.charts, "flowSurfaces applyBlueprint assets.charts")
+  };
+  const tabs = normalizeTabs(input.tabs);
+  const reaction = normalizeReaction(input.reaction);
+  if (tabs.length > 1 && (page == null ? void 0 : page.enableTabs) === false) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint page.enableTabs cannot be false when tabs.length > 1`);
+  }
+  return {
+    version: "1",
+    mode,
+    ...target ? { target } : {},
+    ...navigation ? { navigation } : {},
+    ...page ? { page } : {},
+    ...defaults ? { defaults } : {},
+    tabs,
+    assets,
+    ...reaction ? { reaction } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prepareFlowSurfaceApplyBlueprintDocument
+});

package/dist/server/flow-surfaces/blueprint/private-utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+import type { FlowSurfaceApplyBlueprintAssetMap } from './public-types';
+export declare const APPLY_BLUEPRINT_CREATE_MENU_GROUP_METADATA_KEYS: readonly ["icon", "tooltip", "hideInMenu"];
+export declare function assertPlainObject(value: any, context: string): void;
+export declare function assertOnlyAllowedKeys(input: Record<string, any>, context: string, allowedKeys: string[]): void;
+export declare function normalizeApplyBlueprintToken(value: any, fallback?: string): string;
+export declare function readString(value: any): string;
+export declare function readOptionalString(value: any): string;
+export declare function readBoolean(value: any, context: string): boolean;
+export declare function assertNonEmptyString(value: any, context: string): string;
+export declare function readOptionalArray<T = any>(value: any, context: string): T[] | undefined;
+export declare function cloneOptionalPlainObject<T extends Record<string, any>>(value: any, context: string): T | undefined;
+export declare function buildApplyBlueprintTabPublicPath(index: number): string;
+export declare function buildScopedKey(scopePrefix: string, localKey: string): string;
+export declare function normalizeBlueprintLocalKey(rawValue: any, fallback: string, context: string): string;
+export declare function normalizeTabLocalKey(rawKey: any, fallback: string, index: number, usedKeys: Set<string>, options: {
+    explicit: boolean;
+}): string;
+export declare function normalizeAssetRegistry(input: any, context: string): FlowSurfaceApplyBlueprintAssetMap;

package/dist/server/flow-surfaces/blueprint/private-utils.js

@@ -0,0 +1,182 @@
+/**
+ * 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 private_utils_exports = {};
+__export(private_utils_exports, {
+  APPLY_BLUEPRINT_CREATE_MENU_GROUP_METADATA_KEYS: () => APPLY_BLUEPRINT_CREATE_MENU_GROUP_METADATA_KEYS,
+  assertNonEmptyString: () => assertNonEmptyString,
+  assertOnlyAllowedKeys: () => assertOnlyAllowedKeys,
+  assertPlainObject: () => assertPlainObject,
+  buildApplyBlueprintTabPublicPath: () => buildApplyBlueprintTabPublicPath,
+  buildScopedKey: () => buildScopedKey,
+  cloneOptionalPlainObject: () => cloneOptionalPlainObject,
+  normalizeApplyBlueprintToken: () => normalizeApplyBlueprintToken,
+  normalizeAssetRegistry: () => normalizeAssetRegistry,
+  normalizeBlueprintLocalKey: () => normalizeBlueprintLocalKey,
+  normalizeTabLocalKey: () => normalizeTabLocalKey,
+  readBoolean: () => readBoolean,
+  readOptionalArray: () => readOptionalArray,
+  readOptionalString: () => readOptionalString,
+  readString: () => readString
+});
+module.exports = __toCommonJS(private_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("../errors");
+var import_service_utils = require("../service-utils");
+const APPLY_BLUEPRINT_CREATE_MENU_GROUP_METADATA_KEYS = ["icon", "tooltip", "hideInMenu"];
+function assertPlainObject(value, context) {
+  if (!import_lodash.default.isPlainObject(value)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an object`);
+  }
+}
+function assertOnlyAllowedKeys(input, context, allowedKeys) {
+  const unsupportedKeys = Object.keys(input || {}).filter((key) => !allowedKeys.includes(key));
+  if (!unsupportedKeys.length) {
+    return;
+  }
+  (0, import_errors.throwBadRequest)(
+    `${context} only accepts keys ${allowedKeys.join(", ")}; unsupported keys: ${unsupportedKeys.join(", ")}`
+  );
+}
+function normalizeApplyBlueprintToken(value, fallback = "item") {
+  const normalized = String(value || "").trim().replace(/[.[\](){}]+/g, "_").replace(/[^a-zA-Z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || fallback;
+}
+function readString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function readOptionalString(value) {
+  const normalized = readString(value);
+  return normalized || void 0;
+}
+function readBoolean(value, context) {
+  if (import_lodash.default.isUndefined(value)) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    (0, import_errors.throwBadRequest)(`${context} must be a boolean`);
+  }
+  return value;
+}
+function assertNonEmptyString(value, context) {
+  const normalized = readString(value);
+  if (!normalized) {
+    (0, import_errors.throwBadRequest)(`${context} must be a non-empty string`);
+  }
+  return normalized;
+}
+function readOptionalArray(value, context) {
+  if (import_lodash.default.isUndefined(value)) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an array`);
+  }
+  return value;
+}
+function cloneOptionalPlainObject(value, context) {
+  if (import_lodash.default.isUndefined(value)) {
+    return void 0;
+  }
+  assertPlainObject(value, context);
+  return import_lodash.default.cloneDeep(value);
+}
+function buildApplyBlueprintTabPublicPath(index) {
+  return `flowSurfaces applyBlueprint tabs[${index}]`;
+}
+function buildScopedKey(scopePrefix, localKey) {
+  return scopePrefix ? `${scopePrefix}.${localKey}` : localKey;
+}
+function normalizeBlueprintLocalKey(rawValue, fallback, context) {
+  const explicit = readString(rawValue);
+  if (explicit) {
+    return (0, import_service_utils.normalizeFlowSurfaceComposeKey)(explicit, context);
+  }
+  return (0, import_service_utils.normalizeFlowSurfaceComposeKey)(normalizeApplyBlueprintToken(fallback, fallback), context);
+}
+function normalizeTabLocalKey(rawKey, fallback, index, usedKeys, options) {
+  const normalizedBase = normalizeBlueprintLocalKey(rawKey, fallback, `flowSurfaces applyBlueprint tabs[${index}].key`);
+  if (!usedKeys.has(normalizedBase)) {
+    usedKeys.add(normalizedBase);
+    return normalizedBase;
+  }
+  if (options.explicit) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces applyBlueprint tabs[${index}].key '${normalizedBase}' is duplicated`);
+  }
+  let suffix = 2;
+  let candidate = `${normalizedBase}_${suffix}`;
+  while (usedKeys.has(candidate)) {
+    suffix += 1;
+    candidate = `${normalizedBase}_${suffix}`;
+  }
+  usedKeys.add(candidate);
+  return candidate;
+}
+function normalizeAssetRegistry(input, context) {
+  if (import_lodash.default.isUndefined(input)) {
+    return {};
+  }
+  if (!import_lodash.default.isPlainObject(input)) {
+    (0, import_errors.throwBadRequest)(`${context} must be an object map`);
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => {
+      const normalizedKey = assertNonEmptyString(key, `${context} key`);
+      if (!import_lodash.default.isPlainObject(value)) {
+        (0, import_errors.throwBadRequest)(`${context}['${normalizedKey}'] must be an object`);
+      }
+      return [normalizedKey, import_lodash.default.cloneDeep(value)];
+    })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPLY_BLUEPRINT_CREATE_MENU_GROUP_METADATA_KEYS,
+  assertNonEmptyString,
+  assertOnlyAllowedKeys,
+  assertPlainObject,
+  buildApplyBlueprintTabPublicPath,
+  buildScopedKey,
+  cloneOptionalPlainObject,
+  normalizeApplyBlueprintToken,
+  normalizeAssetRegistry,
+  normalizeBlueprintLocalKey,
+  normalizeTabLocalKey,
+  readBoolean,
+  readOptionalArray,
+  readOptionalString,
+  readString
+});