@dataverse-kit/form-runtime 0.1.0

package/dist/types.cjs

@@ -0,0 +1,976 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  BPF_CONDITION_NODE_DISPLAY: () => BPF_CONDITION_NODE_DISPLAY,
+  BPF_EDGE_DISPLAY: () => BPF_EDGE_DISPLAY,
+  BPF_STAGE_STATUSES: () => BPF_STAGE_STATUSES,
+  BPF_STEP_TYPES: () => BPF_STEP_TYPES,
+  DEFAULT_FORM_GRID_LAYOUT: () => DEFAULT_FORM_GRID_LAYOUT,
+  DEFAULT_THEME: () => DEFAULT_THEME,
+  FOCUSED_VIEW_ICON_OPTIONS: () => FOCUSED_VIEW_ICON_OPTIONS,
+  MAX_FOCUSED_VIEW_ROWS: () => MAX_FOCUSED_VIEW_ROWS,
+  PRIMARY_CAPABLE_VARIANTS: () => PRIMARY_CAPABLE_VARIANTS,
+  STANDARD_COLORS: () => STANDARD_COLORS,
+  THEME_PRESETS: () => THEME_PRESETS,
+  convertDataverseBPFToDefinition: () => convertDataverseBPFToDefinition,
+  createBPFInstance: () => createBPFInstance,
+  createConfigFromColumns: () => createConfigFromColumns,
+  createDefaultBPF: () => createDefaultBPF,
+  createDefaultBPFConditionNode: () => createDefaultBPFConditionNode,
+  createDefaultBPFEdge: () => createDefaultBPFEdge,
+  createDefaultBPFStage: () => createDefaultBPFStage,
+  createDefaultBPFStep: () => createDefaultBPFStep,
+  createDefaultBusinessRule: () => createDefaultBusinessRule,
+  createDefaultCardViewConfig: () => createDefaultCardViewConfig,
+  createDefaultCompositeRendererConfig: () => createDefaultCompositeRendererConfig,
+  createDefaultCompositeSlot: () => createDefaultCompositeSlot,
+  createDefaultFieldState: () => createDefaultFieldState,
+  createDefaultFocusedViewConfig: () => createDefaultFocusedViewConfig,
+  createDefaultGridColumn: () => createDefaultGridColumn,
+  createDefaultGridCustomizer: () => createDefaultGridCustomizer,
+  createDefaultToolbarConfig: () => createDefaultToolbarConfig,
+  createFormSelectorRule: () => createFormSelectorRule,
+  entityIconMap: () => entityIconMap,
+  generateGridId: () => generateGridId,
+  getActionTargets: () => getActionTargets,
+  getConditionNodeById: () => getConditionNodeById,
+  getDefaultEdge: () => getDefaultEdge,
+  getEntityIcon: () => getEntityIcon,
+  getIncomingEdges: () => getIncomingEdges,
+  getOutgoingEdges: () => getOutgoingEdges,
+  getResolvedThemeColors: () => getResolvedThemeColors,
+  getThemeById: () => getThemeById,
+  hasBranching: () => hasBranching,
+  isAuditTab: () => isAuditTab,
+  isConditionGroup: () => isConditionGroup,
+  isConditionNode: () => isConditionNode,
+  isMainTab: () => isMainTab,
+  isRelatedTab: () => isRelatedTab,
+  isValidFocusedViewConfig: () => isValidFocusedViewConfig,
+  migrateLegacyConfig: () => migrateLegacyConfig,
+  toFormSummary: () => toFormSummary
+});
+module.exports = __toCommonJS(types_exports);
+
+// src/types/control.ts
+var PRIMARY_CAPABLE_VARIANTS = ["default", "compound", "split", "toggle"];
+
+// src/types/form.ts
+var DEFAULT_FORM_GRID_LAYOUT = {
+  columns: 12,
+  rowHeight: 80,
+  gap: 12
+};
+function isMainTab(tab) {
+  return tab.tabType === "main" || !("tabType" in tab) || tab.tabType === void 0;
+}
+function isRelatedTab(tab) {
+  return tab.tabType === "related";
+}
+function isAuditTab(tab) {
+  return tab.tabType === "audit";
+}
+
+// src/types/theme.ts
+var THEME_PRESETS = [
+  {
+    id: "soft-blue",
+    name: "Soft blue",
+    colors: {
+      primary: "#0078d4",
+      primaryDark: "#005a9e",
+      headerBackground: "#ffffff",
+      sectionBackground: "#ffffff",
+      canvasBackground: "#f3f2f1",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#edebe9",
+      inputBackground: "#ffffff",
+      inputBorder: "#8a8886"
+    }
+  },
+  {
+    id: "blue",
+    name: "Blue",
+    colors: {
+      primary: "#0078d4",
+      primaryDark: "#005a9e",
+      headerBackground: "#0078d4",
+      sectionBackground: "#e6f2ff",
+      canvasBackground: "#e6f2ff",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#c7e0f4",
+      inputBackground: "#ffffff",
+      inputBorder: "#0078d4"
+    }
+  },
+  {
+    id: "light",
+    name: "Light",
+    colors: {
+      primary: "#605e5c",
+      primaryDark: "#3b3a39",
+      headerBackground: "#f5f5f5",
+      sectionBackground: "#ffffff",
+      canvasBackground: "#fafafa",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#e1dfdd",
+      inputBackground: "#ffffff",
+      inputBorder: "#8a8886"
+    }
+  },
+  {
+    id: "coral",
+    name: "Coral",
+    colors: {
+      primary: "#d83b01",
+      primaryDark: "#a52a00",
+      headerBackground: "#d83b01",
+      sectionBackground: "#fff4f0",
+      canvasBackground: "#fff4f0",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#f3d6cd",
+      inputBackground: "#ffffff",
+      inputBorder: "#d83b01"
+    }
+  },
+  {
+    id: "red",
+    name: "Red",
+    colors: {
+      primary: "#a4262c",
+      primaryDark: "#7e1e23",
+      headerBackground: "#a4262c",
+      sectionBackground: "#fdf3f4",
+      canvasBackground: "#fdf3f4",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#f1d3d5",
+      inputBackground: "#ffffff",
+      inputBorder: "#a4262c"
+    }
+  },
+  {
+    id: "steel",
+    name: "Steel",
+    colors: {
+      primary: "#004578",
+      primaryDark: "#002d4e",
+      headerBackground: "#004578",
+      sectionBackground: "#f0f4f7",
+      canvasBackground: "#e8eef2",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#c8d4dc",
+      inputBackground: "#ffffff",
+      inputBorder: "#004578"
+    }
+  },
+  {
+    id: "dune",
+    name: "Dune",
+    colors: {
+      primary: "#7a6855",
+      primaryDark: "#5c4f3f",
+      headerBackground: "#7a6855",
+      sectionBackground: "#f5f3f0",
+      canvasBackground: "#e8e4df",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#d6d0c8",
+      inputBackground: "#ffffff",
+      inputBorder: "#7a6855"
+    }
+  },
+  {
+    id: "lavender",
+    name: "Lavender",
+    colors: {
+      primary: "#5c2d91",
+      primaryDark: "#472270",
+      headerBackground: "#5c2d91",
+      sectionBackground: "#f9f5ff",
+      canvasBackground: "#f5f0fa",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#e1d4f0",
+      inputBackground: "#ffffff",
+      inputBorder: "#5c2d91"
+    }
+  },
+  {
+    id: "brown",
+    name: "Brown",
+    colors: {
+      primary: "#6d4c41",
+      primaryDark: "#4e362e",
+      headerBackground: "#6d4c41",
+      sectionBackground: "#f5f0ed",
+      canvasBackground: "#ebe5e1",
+      textPrimary: "#323130",
+      textSecondary: "#605e5c",
+      border: "#d4ccc7",
+      inputBackground: "#ffffff",
+      inputBorder: "#6d4c41"
+    }
+  }
+];
+var DEFAULT_THEME = THEME_PRESETS[0];
+var STANDARD_COLORS = [
+  "#ffffff",
+  "#000000",
+  "#1a1a1a",
+  "#333333",
+  "#4d4d4d",
+  "#666666",
+  "#808080",
+  "#999999",
+  "#b3b3b3",
+  "#cccccc",
+  "#a4262c",
+  "#d83b01",
+  "#ff8c00",
+  "#ffb900",
+  "#fff100",
+  "#bad80a",
+  "#107c10",
+  "#00b294",
+  "#0078d4",
+  "#5c2d91"
+];
+function getThemeById(id) {
+  return THEME_PRESETS.find((t) => t.id === id) ?? DEFAULT_THEME;
+}
+function getResolvedThemeColors(themeSettings) {
+  const theme = getThemeById(themeSettings?.presetId ?? "soft-blue");
+  if (themeSettings?.customBackgroundColor) {
+    return {
+      ...theme.colors,
+      canvasBackground: themeSettings.customBackgroundColor
+    };
+  }
+  return theme.colors;
+}
+
+// src/types/focusedView.ts
+var FOCUSED_VIEW_ICON_OPTIONS = [
+  { iconName: "", label: "None" },
+  { iconName: "FavoriteStarFill", label: "Star" },
+  { iconName: "NumberSymbol", label: "Number" },
+  { iconName: "Clock", label: "Time" },
+  { iconName: "Phone", label: "Phone" },
+  { iconName: "Mail", label: "Email" },
+  { iconName: "Calendar", label: "Calendar" },
+  { iconName: "Contact", label: "Contact" },
+  { iconName: "Money", label: "Currency" },
+  { iconName: "StatusCircleCheckmark", label: "Status" }
+];
+var MAX_FOCUSED_VIEW_ROWS = 4;
+function migrateLegacyConfig(primaryNameField, summaryFields) {
+  const rows = [];
+  if (primaryNameField) {
+    rows.push({
+      id: "row-1",
+      primaryField: {
+        fieldName: primaryNameField,
+        label: toDisplayName(primaryNameField)
+      }
+    });
+  }
+  summaryFields.slice(0, MAX_FOCUSED_VIEW_ROWS - 1).forEach((sf, index) => {
+    rows.push({
+      id: `row-${index + 2}`,
+      primaryField: {
+        fieldName: sf.fieldName,
+        label: sf.label
+      }
+    });
+  });
+  return { rows };
+}
+function toDisplayName(fieldName) {
+  return fieldName.replace(/([A-Z])/g, " $1").replace(/_/g, " ").replace(/^\s+/, "").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").trim();
+}
+function createDefaultFocusedViewConfig(primaryNameField = "name") {
+  return {
+    rows: [
+      {
+        id: "row-1",
+        primaryField: {
+          fieldName: primaryNameField,
+          label: toDisplayName(primaryNameField)
+        }
+      }
+    ],
+    showUpNextActivity: false
+  };
+}
+function isValidFocusedViewConfig(config) {
+  if (!config || typeof config !== "object") return false;
+  const c = config;
+  if (!Array.isArray(c.rows)) return false;
+  if (c.rows.length === 0 || c.rows.length > MAX_FOCUSED_VIEW_ROWS) return false;
+  return c.rows.every(
+    (row) => row.id && row.primaryField && typeof row.primaryField.fieldName === "string" && typeof row.primaryField.label === "string"
+  );
+}
+function createConfigFromColumns(columns) {
+  if (!columns || columns.length === 0) {
+    return createDefaultFocusedViewConfig();
+  }
+  const rows = columns.slice(0, MAX_FOCUSED_VIEW_ROWS).map((col, index) => ({
+    id: `row-${index + 1}`,
+    primaryField: {
+      fieldName: col.fieldName,
+      label: col.name || toDisplayName(col.fieldName)
+    }
+  }));
+  return {
+    rows,
+    showUpNextActivity: false
+  };
+}
+
+// src/types/businessRules.ts
+function isConditionGroup(c) {
+  return "logic" in c;
+}
+function getActionTargets(action) {
+  return action.targets?.length ? action.targets : [action.target];
+}
+function createDefaultBusinessRule(entityLogicalName, name = "New Rule") {
+  const id = `rule-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id,
+    name,
+    entityLogicalName,
+    scope: "entity",
+    trigger: { type: "onLoad" },
+    priority: 100,
+    enabled: true,
+    dataSources: [],
+    variables: [],
+    conditionTree: {
+      id: `grp-${Date.now()}`,
+      logic: "and",
+      conditions: []
+    },
+    thenActions: [],
+    elseActions: [],
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function createDefaultFieldState() {
+  return {
+    visible: true,
+    locked: false,
+    required: "none"
+  };
+}
+
+// src/types/bpf.ts
+function uid(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function createDefaultBPFStep(type = "data", order = 1) {
+  return {
+    id: uid("step"),
+    name: "New Step",
+    order,
+    type,
+    required: false
+  };
+}
+function createDefaultBPFStage(order = 1) {
+  return {
+    id: uid("stage"),
+    name: "New Stage",
+    order,
+    status: "pending",
+    steps: []
+  };
+}
+function createDefaultBPFEdge(fromStageId, toStageId, options) {
+  return {
+    id: uid("edge"),
+    fromStageId,
+    toStageId,
+    label: options?.label,
+    condition: options?.condition,
+    isDefault: options?.isDefault ?? false,
+    order: options?.order ?? 0
+  };
+}
+function createDefaultBPFConditionNode(name = "New Condition", condition) {
+  return {
+    id: uid("cond"),
+    name,
+    condition: condition ?? {
+      id: uid("grp"),
+      logic: "and",
+      conditions: []
+    }
+  };
+}
+function createDefaultBPF(entityLogicalName, name = "New Business Process Flow") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: uid("bpf"),
+    name,
+    entityLogicalName,
+    source: "custom",
+    stages: [
+      {
+        ...createDefaultBPFStage(1),
+        name: "Stage 1",
+        status: "active"
+      },
+      {
+        ...createDefaultBPFStage(2),
+        name: "Stage 2"
+      },
+      {
+        ...createDefaultBPFStage(3),
+        name: "Stage 3"
+      }
+    ],
+    activeStageIndex: 0,
+    isActive: true,
+    allowBackNavigation: true,
+    showStageLabels: true,
+    progressVariant: "chevron",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function createBPFInstance(bpf, recordId) {
+  const firstStage = bpf.stages[0];
+  return {
+    id: uid("inst"),
+    bpfDefinitionId: bpf.id,
+    recordId,
+    entityLogicalName: bpf.entityLogicalName,
+    activeStageId: firstStage?.id ?? "",
+    completedStageIds: [],
+    skippedStageIds: [],
+    completedStepIds: [],
+    pathHistory: firstStage ? [firstStage.id] : [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function mapAttributeTypeToFieldType(attributeType, format) {
+  switch (attributeType) {
+    case "String":
+      if (format === "Email" || format === "Url" || format === "Phone") {
+        return "text";
+      }
+      return "text";
+    case "Memo":
+      return "textarea";
+    case "Integer":
+    case "BigInt":
+      return "number";
+    case "Decimal":
+    case "Double":
+      return "decimal";
+    case "Money":
+      return "currency";
+    case "DateTime":
+      if (format === "DateOnly") {
+        return "date";
+      }
+      return "datetime";
+    case "Boolean":
+      return "boolean";
+    case "Lookup":
+    case "Customer":
+    case "PartyList":
+      return "lookup";
+    case "Owner":
+      return "owner";
+    case "Picklist":
+    case "State":
+    case "Status":
+      return "optionset";
+    case "MultiSelectPicklist":
+      return "multiselect";
+    default:
+      return "text";
+  }
+}
+function createStepFromStepInfo(stepInfo, stepIndex) {
+  const fieldType = mapAttributeTypeToFieldType(
+    stepInfo.attributeType,
+    stepInfo.format
+  );
+  const step = {
+    id: uid("step"),
+    name: stepInfo.displayName || stepInfo.controlId,
+    order: stepIndex + 1,
+    type: "data",
+    required: stepInfo.isRequired ?? false,
+    fieldLogicalName: stepInfo.controlId,
+    fieldDisplayName: stepInfo.displayName,
+    fieldType
+  };
+  if ((fieldType === "lookup" || fieldType === "owner") && stepInfo.lookupTargets && stepInfo.lookupTargets.length > 0) {
+    step.lookupTargetEntity = stepInfo.lookupTargets[0];
+    if (stepInfo.lookupTargets.length > 1) {
+      step.lookupTargetEntities = stepInfo.lookupTargets;
+    }
+  }
+  if ((fieldType === "optionset" || fieldType === "multiselect") && stepInfo.options && stepInfo.options.length > 0) {
+    step.options = stepInfo.options;
+  }
+  return step;
+}
+function convertDataverseBPFToDefinition(metadata) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sortedStages = [...metadata.stages].sort(
+    (a, b) => a.stageCategory - b.stageCategory
+  );
+  const stageIdMap = /* @__PURE__ */ new Map();
+  const stages = sortedStages.map((stageMeta, index) => {
+    const internalId = uid("stage");
+    stageIdMap.set(stageMeta.stageId.toLowerCase(), internalId);
+    let steps;
+    if (stageMeta.parsedSteps && stageMeta.parsedSteps.length > 0) {
+      steps = stageMeta.parsedSteps.map(
+        (stepInfo, stepIndex) => createStepFromStepInfo(stepInfo, stepIndex)
+      );
+    } else {
+      steps = stageMeta.requiredAttributes.map((attr, stepIndex) => ({
+        id: uid("step"),
+        name: attr,
+        order: stepIndex + 1,
+        type: "data",
+        required: false,
+        // Default to not required when we don't have parsed data
+        fieldLogicalName: attr,
+        fieldType: "text"
+        // Default to text when no metadata
+      }));
+    }
+    return {
+      id: internalId,
+      name: stageMeta.name,
+      order: index + 1,
+      status: index === 0 ? "active" : "pending",
+      dataverseStageId: stageMeta.stageId,
+      dataverseStageCategory: stageMeta.stageCategory,
+      steps
+    };
+  });
+  let edges;
+  let conditionNodes;
+  if (metadata.branchData?.hasBranching) {
+    const condNodeIdMap = /* @__PURE__ */ new Map();
+    conditionNodes = metadata.branchData.conditionNodes.map((condInfo) => {
+      const internalId = uid("cond");
+      condNodeIdMap.set(condInfo.nodeId.toLowerCase(), internalId);
+      const condition = buildConditionGroupFromBranch(condInfo);
+      return {
+        id: internalId,
+        name: condInfo.name,
+        description: condInfo.conditionExpression,
+        condition
+      };
+    });
+    edges = metadata.branchData.branches.map((branch) => {
+      let fromId = stageIdMap.get(branch.fromNodeId.toLowerCase()) || condNodeIdMap.get(branch.fromNodeId.toLowerCase());
+      let toId = stageIdMap.get(branch.toStageId.toLowerCase());
+      if (!fromId || !toId) {
+        return null;
+      }
+      let edgeCondition;
+      if (!branch.isDefault && branch.conditionField) {
+        edgeCondition = buildConditionGroupFromBranch({
+          nodeId: "",
+          name: "",
+          conditionField: branch.conditionField,
+          conditionOperator: branch.conditionOperator,
+          conditionValue: branch.conditionValue
+        });
+      }
+      return {
+        id: uid("edge"),
+        fromStageId: fromId,
+        toStageId: toId,
+        label: branch.label,
+        condition: edgeCondition,
+        isDefault: branch.isDefault,
+        order: branch.order ?? 0
+      };
+    }).filter((e) => e !== null);
+  }
+  const bpf = {
+    id: uid("bpf"),
+    name: metadata.name,
+    description: metadata.description,
+    entityLogicalName: metadata.primaryEntity,
+    source: "dataverse",
+    dataverseWorkflowId: metadata.workflowId,
+    dataverseUniqueName: metadata.uniqueName,
+    stages,
+    activeStageIndex: 0,
+    isActive: metadata.stateCode === 1,
+    allowBackNavigation: true,
+    showStageLabels: true,
+    progressVariant: "chevron",
+    createdAt: now,
+    updatedAt: now
+  };
+  if (edges && edges.length > 0) {
+    bpf.edges = edges;
+  }
+  if (conditionNodes && conditionNodes.length > 0) {
+    bpf.conditionNodes = conditionNodes;
+  }
+  return bpf;
+}
+function buildConditionGroupFromBranch(condInfo) {
+  const conditions = [];
+  if (condInfo.conditionField) {
+    const opMap = {
+      "eq": "eq",
+      "=": "eq",
+      "equals": "eq",
+      "ne": "ne",
+      "!=": "ne",
+      "notequals": "ne",
+      "gt": "gt",
+      ">": "gt",
+      "ge": "ge",
+      ">=": "ge",
+      "lt": "lt",
+      "<": "lt",
+      "le": "le",
+      "<=": "le",
+      "like": "like",
+      "null": "null",
+      "not-null": "not-null",
+      "notnull": "not-null"
+    };
+    const operator = opMap[condInfo.conditionOperator?.toLowerCase() ?? "eq"] ?? "eq";
+    conditions.push({
+      id: uid("cond"),
+      source: "field",
+      fieldName: condInfo.conditionField,
+      operator,
+      value: condInfo.conditionValue
+    });
+  }
+  return {
+    id: uid("grp"),
+    logic: "and",
+    conditions
+  };
+}
+var BPF_STEP_TYPES = {
+  data: {
+    label: "Data Entry",
+    icon: "TextField",
+    description: "Requires a field value to be entered"
+  },
+  workflow: {
+    label: "Workflow",
+    icon: "Flow",
+    description: "Runs a Dynamics 365 workflow"
+  },
+  action: {
+    label: "Custom Action",
+    icon: "LightningBolt",
+    description: "Executes a custom action"
+  },
+  flow: {
+    label: "Power Automate",
+    icon: "MicrosoftFlowLogo",
+    description: "Triggers a Power Automate flow"
+  }
+};
+var BPF_STAGE_STATUSES = {
+  pending: {
+    label: "Pending",
+    icon: "CircleRing",
+    color: "#605e5c"
+  },
+  active: {
+    label: "Active",
+    icon: "CircleFill",
+    color: "#0078d4"
+  },
+  completed: {
+    label: "Completed",
+    icon: "CheckMark",
+    color: "#107c10"
+  },
+  skipped: {
+    label: "Skipped",
+    icon: "SkipForward",
+    color: "#8a8886"
+  }
+};
+var BPF_CONDITION_NODE_DISPLAY = {
+  label: "Condition",
+  icon: "BranchFork2",
+  color: "#8764b8",
+  // Purple like Dynamics
+  shape: "diamond"
+};
+var BPF_EDGE_DISPLAY = {
+  defaultLabel: "Next",
+  yesLabel: "Yes",
+  noLabel: "No",
+  defaultColor: "#605e5c",
+  conditionalColor: "#0078d4"
+};
+function hasBranching(bpf) {
+  return Boolean(bpf.edges && bpf.edges.length > 0);
+}
+function getOutgoingEdges(bpf, nodeId) {
+  if (!bpf.edges) return [];
+  return bpf.edges.filter((e) => e.fromStageId === nodeId).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+function getIncomingEdges(bpf, nodeId) {
+  if (!bpf.edges) return [];
+  return bpf.edges.filter((e) => e.toStageId === nodeId);
+}
+function getConditionNodeById(bpf, nodeId) {
+  return bpf.conditionNodes?.find((n) => n.id === nodeId);
+}
+function isConditionNode(bpf, nodeId) {
+  return Boolean(bpf.conditionNodes?.some((n) => n.id === nodeId));
+}
+function getDefaultEdge(bpf, nodeId) {
+  const edges = getOutgoingEdges(bpf, nodeId);
+  return edges.find((e) => e.isDefault) ?? edges.find((e) => !e.condition);
+}
+
+// src/types/formSelector.ts
+function createFormSelectorRule(entityLogicalName, targetFormId, name = "New Rule") {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = `fsr-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  return {
+    id,
+    name,
+    entityLogicalName,
+    formType: "main",
+    targetFormId,
+    condition: {
+      id: `grp-${Date.now()}`,
+      logic: "and",
+      conditions: []
+    },
+    priority: 100,
+    enabled: true,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function toFormSummary(form) {
+  return {
+    id: form.id,
+    name: form.name,
+    type: form.type,
+    entityLogicalName: form.settings?.dataSources?.[0]?.entityName,
+    isDefault: form.settings?.isDefaultForEntity,
+    order: form.order,
+    description: form.description,
+    calloutCount: form.callouts?.length ?? 0
+  };
+}
+var entityIconMap = {
+  contact: "Contact",
+  account: "CityNext",
+  opportunity: "Money",
+  lead: "People",
+  case: "Inbox",
+  incident: "Inbox",
+  task: "TaskLogo",
+  appointment: "Calendar",
+  email: "Mail",
+  phonecall: "Phone",
+  quote: "Documentation",
+  order: "Package",
+  invoice: "Money",
+  product: "Product",
+  user: "Contact",
+  team: "Group",
+  businessunit: "Org",
+  systemuser: "Contact"
+};
+function getEntityIcon(entityLogicalName) {
+  const normalizedName = entityLogicalName.toLowerCase().replace(/^new_|^cr\d+_/, "");
+  return entityIconMap[normalizedName] || "TableGroup";
+}
+
+// src/types/gridCustomizer.ts
+var _gridIdCounter = 0;
+function generateGridId(prefix = "gc") {
+  _gridIdCounter++;
+  return `${prefix}_${Date.now()}_${_gridIdCounter}`;
+}
+function createDefaultGridColumn(overrides) {
+  return {
+    id: generateGridId("col"),
+    fieldName: "",
+    displayName: "New Column",
+    dataType: "text",
+    width: 150,
+    minWidth: 50,
+    isResizable: true,
+    isVisible: true,
+    order: 0,
+    rendererType: "text",
+    rendererConfig: {},
+    isSortable: true,
+    isFilterable: false,
+    ...overrides
+  };
+}
+function createDefaultToolbarConfig() {
+  return {
+    showSearch: true,
+    showFilters: false,
+    showViewToggle: false,
+    showExport: false,
+    showRefresh: true,
+    showColumnChooser: false,
+    customButtons: []
+  };
+}
+function createDefaultCardViewConfig() {
+  return {
+    enabled: false,
+    cardsPerRow: 3,
+    cardHeight: 200
+  };
+}
+function createDefaultGridCustomizer(overrides) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: generateGridId("grid"),
+    name: "New Grid",
+    columns: [
+      createDefaultGridColumn({ fieldName: "name", displayName: "Name", order: 0 }),
+      createDefaultGridColumn({ fieldName: "status", displayName: "Status", dataType: "optionset", rendererType: "optionset", order: 1 }),
+      createDefaultGridColumn({ fieldName: "created", displayName: "Created On", dataType: "date", rendererType: "date", order: 2 })
+    ],
+    gridType: "standard",
+    maxVisibleRows: 5,
+    selectionMode: "multiple",
+    paginationMode: "pagination",
+    pageSize: 10,
+    showCommandBar: true,
+    showCommandBarLabels: true,
+    isEditable: false,
+    allowViewChange: true,
+    toolbar: createDefaultToolbarConfig(),
+    cardView: createDefaultCardViewConfig(),
+    showTitle: true,
+    compactMode: false,
+    alternateRowColor: true,
+    alternateRowColors: { even: "#ffffff", odd: "#faf9f8" },
+    nestedSelectionMode: "independent",
+    commandBarItems: [
+      { id: "cmd-new", text: "New", iconName: "Add", position: "primary", actionType: "new" },
+      { id: "cmd-delete", text: "Delete", iconName: "Delete", position: "primary", actionType: "delete" }
+    ],
+    lookupPreview: { enabled: true },
+    sampleDataMode: "auto",
+    createdAt: now,
+    updatedAt: now,
+    ...overrides
+  };
+}
+function createDefaultCompositeSlot(type = "text") {
+  return {
+    id: generateGridId("slot"),
+    type
+  };
+}
+function createDefaultCompositeRendererConfig() {
+  return {
+    layout: "horizontal",
+    gap: 4,
+    slots: [
+      createDefaultCompositeSlot("text")
+    ]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BPF_CONDITION_NODE_DISPLAY,
+  BPF_EDGE_DISPLAY,
+  BPF_STAGE_STATUSES,
+  BPF_STEP_TYPES,
+  DEFAULT_FORM_GRID_LAYOUT,
+  DEFAULT_THEME,
+  FOCUSED_VIEW_ICON_OPTIONS,
+  MAX_FOCUSED_VIEW_ROWS,
+  PRIMARY_CAPABLE_VARIANTS,
+  STANDARD_COLORS,
+  THEME_PRESETS,
+  convertDataverseBPFToDefinition,
+  createBPFInstance,
+  createConfigFromColumns,
+  createDefaultBPF,
+  createDefaultBPFConditionNode,
+  createDefaultBPFEdge,
+  createDefaultBPFStage,
+  createDefaultBPFStep,
+  createDefaultBusinessRule,
+  createDefaultCardViewConfig,
+  createDefaultCompositeRendererConfig,
+  createDefaultCompositeSlot,
+  createDefaultFieldState,
+  createDefaultFocusedViewConfig,
+  createDefaultGridColumn,
+  createDefaultGridCustomizer,
+  createDefaultToolbarConfig,
+  createFormSelectorRule,
+  entityIconMap,
+  generateGridId,
+  getActionTargets,
+  getConditionNodeById,
+  getDefaultEdge,
+  getEntityIcon,
+  getIncomingEdges,
+  getOutgoingEdges,
+  getResolvedThemeColors,
+  getThemeById,
+  hasBranching,
+  isAuditTab,
+  isConditionGroup,
+  isConditionNode,
+  isMainTab,
+  isRelatedTab,
+  isValidFocusedViewConfig,
+  migrateLegacyConfig,
+  toFormSummary
+});
+//# sourceMappingURL=types.cjs.map