@dimescheduler/setup 0.1.2 → 0.11.4

package/dist/chunk-3PMKH6IT.js

@@ -0,0 +1,1023 @@
+// src/core/compile/bundle.ts
+import { readFile } from "fs/promises";
+import { dirname, resolve } from "path";
+import JSON5 from "json5";
+
+// src/core/types.ts
+function isProfileDocument(doc) {
+  return typeof doc === "object" && doc !== null && doc.type === "profile";
+}
+function isUsersDocument(doc) {
+  return typeof doc === "object" && doc !== null && doc.type === "users";
+}
+function isLayoutsDocument(doc) {
+  return typeof doc === "object" && doc !== null && doc.type === "layouts";
+}
+function isConfigurationDocument(doc) {
+  return typeof doc === "object" && doc !== null && doc.type === "configuration";
+}
+function isBundleDocument(doc) {
+  return typeof doc === "object" && doc !== null && doc.type === "bundle";
+}
+function isDocumentReference(item) {
+  return "$ref" in item;
+}
+function detectDocumentType(doc) {
+  if (typeof doc !== "object" || doc === null) return null;
+  const type = doc.type;
+  if (type === "profile" || type === "users" || type === "layouts" || type === "configuration" || type === "bundle") {
+    return type;
+  }
+  return null;
+}
+
+// src/core/compile/merge.ts
+function hasConflicts(a, b, key) {
+  const aKeys = new Set(a.map((item) => item[key]));
+  return b.some((item) => aKeys.has(item[key]));
+}
+function mergeLayouts(existing, incoming, strategy = "append") {
+  if (strategy === "replace") {
+    return [...incoming];
+  }
+  if (strategy === "error" && hasConflicts(existing, incoming, "code")) {
+    const existingCodes = new Set(existing.map((l) => l.code));
+    const conflicts = incoming.filter((l) => existingCodes.has(l.code)).map((l) => l.code);
+    throw new Error(`Layout code conflict detected: ${conflicts.join(", ")}`);
+  }
+  const merged = [...existing];
+  for (const layout of incoming) {
+    const existingIndex = merged.findIndex((l) => l.code === layout.code);
+    if (existingIndex >= 0) {
+      merged[existingIndex] = layout;
+    } else {
+      merged.push(layout);
+    }
+  }
+  return merged;
+}
+function mergeUsers(existing, incoming, strategy = "append") {
+  if (strategy === "replace") {
+    return [...incoming];
+  }
+  if (strategy === "error" && hasConflicts(existing, incoming, "email")) {
+    const existingEmails = new Set(existing.map((u) => u.email));
+    const conflicts = incoming.filter((u) => existingEmails.has(u.email)).map((u) => u.email);
+    throw new Error(`User email conflict detected: ${conflicts.join(", ")}`);
+  }
+  const merged = [...existing];
+  for (const user of incoming) {
+    const existingIndex = merged.findIndex((u) => u.email === user.email);
+    if (existingIndex >= 0) {
+      merged[existingIndex] = user;
+    } else {
+      merged.push(user);
+    }
+  }
+  return merged;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue === void 0) {
+      continue;
+    }
+    if (Array.isArray(sourceValue)) {
+      if (Array.isArray(targetValue)) {
+        result[key] = [...targetValue, ...sourceValue];
+      } else {
+        result[key] = [...sourceValue];
+      }
+    } else if (typeof sourceValue === "object" && sourceValue !== null && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function setPath(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  if (Array.isArray(value) && Array.isArray(current[lastPart])) {
+    current[lastPart] = [...current[lastPart], ...value];
+  } else if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof current[lastPart] === "object" && current[lastPart] !== null && !Array.isArray(current[lastPart])) {
+    current[lastPart] = deepMerge(
+      current[lastPart],
+      value
+    );
+  } else {
+    current[lastPart] = value;
+  }
+}
+function applyMergeOverrides(doc, mergeOverrides) {
+  const result = JSON.parse(JSON.stringify(doc));
+  for (const [path, value] of Object.entries(mergeOverrides)) {
+    setPath(result, path, value);
+  }
+  return result;
+}
+
+// src/core/compile/mappers.ts
+var SNAP_MODE_MAP = {
+  "none": 1,
+  "off": 1,
+  "5min": 2,
+  "5minutes": 2,
+  "10min": 3,
+  "10minutes": 3,
+  "15min": 4,
+  "15minutes": 4,
+  "30min": 5,
+  "30minutes": 5,
+  "halfhour": 5,
+  "1hour": 6,
+  "1h": 6,
+  "hour": 6,
+  "12hours": 7,
+  "12h": 7,
+  "1day": 8,
+  "1d": 8,
+  "day": 8,
+  "2hours": 9,
+  "2h": 9,
+  "4hours": 10,
+  "4h": 10,
+  // Numeric string mappings
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4,
+  "5": 5,
+  "6": 6,
+  "7": 7,
+  "8": 8,
+  "9": 9,
+  "10": 10
+};
+function mapSnapMode(mode) {
+  if (mode === void 0 || mode === null) return 6;
+  return SNAP_MODE_MAP[String(mode).toLowerCase()] ?? 6;
+}
+var RANGE_MODE_MAP = {
+  "day": 1,
+  "days": 1,
+  "hours": 1,
+  "week": 2,
+  "weeks": 2,
+  "month": 3,
+  "months": 3,
+  "custom": 4,
+  // Numeric string mappings
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4
+};
+function mapRangeMode(mode) {
+  if (mode === void 0 || mode === null) return 2;
+  return RANGE_MODE_MAP[String(mode).toLowerCase()] ?? 2;
+}
+var START_MODE_MAP = {
+  "today": 1,
+  "absolute": 1,
+  "startofweek": 2,
+  "relative": 2,
+  "startofmonth": 3,
+  "todayoffset": 4,
+  // Numeric string mappings
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4
+};
+function mapStartMode(mode) {
+  if (mode === void 0 || mode === null) return 2;
+  return START_MODE_MAP[String(mode).toLowerCase().replace(/\s+/g, "")] ?? 2;
+}
+function mapUnitOfDistance(unit) {
+  if (!unit) return "Kilometers";
+  const v = unit.toLowerCase();
+  if (["km", "kilometer", "kilometers"].includes(v)) return "Kilometers";
+  if (["mi", "mile", "miles"].includes(v)) return "Miles";
+  return unit;
+}
+var COMPONENT_TO_GL = {
+  // Friendly names (user-facing DSL names)
+  "openTasks": "openTasksGridComponent",
+  "planningBoard": "schedulerComponent",
+  "map": "mapComponent",
+  "indicators": "categoriesComponent",
+  "resourceFilters": "filterComponent",
+  "plannedTasks": "plannedTasksGridComponent",
+  "details": "propertygridComponent",
+  "datePicker": "datePickerComponent",
+  "gantt": "ganttComponent",
+  "capacity": "capacityComponent",
+  "routeSequence": "routeSequenceComponent",
+  "notifications": "notificationsComponent",
+  // Internal names (for backwards compatibility)
+  "mapComponent": "mapComponent",
+  "plannedTasksGridComponent": "plannedTasksGridComponent",
+  "propertygridComponent": "propertygridComponent",
+  "datePickerComponent": "datePickerComponent",
+  "ganttComponent": "ganttComponent",
+  "capacityComponent": "capacityComponent",
+  "routeSequenceComponent": "routeSequenceComponent",
+  "notificationsComponent": "notificationsComponent"
+};
+var CONTEXT_TO_API_CONTEXT = {
+  "planningBoard": "scheduler",
+  "openTasks": "unplannedTasksGrid",
+  "plannedTasks": "plannedTasksGrid",
+  "notifications": "notificationsGrid",
+  "details": "detailsGrid",
+  "capacity": "pivotGrid",
+  "gantt": "gantt",
+  "routeSequence": "routeSequenceGrid"
+};
+function componentToGlName(name) {
+  return COMPONENT_TO_GL[name] ?? name;
+}
+function contextToApiContext(context) {
+  return CONTEXT_TO_API_CONTEXT[context] ?? context;
+}
+var VIEW_PRESET_MAP = {
+  "day": "1",
+  "1": "1",
+  "week": "2",
+  "2": "2",
+  "workweek": "3",
+  "workWeek": "3",
+  "work_week": "3",
+  "3": "3",
+  "month": "4",
+  "4": "4"
+};
+function mapViewPreset(value) {
+  if (value === void 0 || value === null) return "2";
+  const v = String(value).toLowerCase().replace(/[\s_-]+/g, "");
+  return VIEW_PRESET_MAP[v] ?? String(value);
+}
+var ROW_HEIGHT_MAP = {
+  "1row": 25,
+  "1rows": 25,
+  "1": 25,
+  "25": 25,
+  "2rows": 38,
+  "2row": 38,
+  "2": 38,
+  "38": 38,
+  "3rows": 50,
+  "3row": 50,
+  "3": 50,
+  "50": 50,
+  "4rows": 63,
+  "4row": 63,
+  "4": 63,
+  "63": 63
+};
+function mapRowHeight(value) {
+  if (value === void 0 || value === null) return 38;
+  const v = String(value).toLowerCase().replace(/[\s_-]+/g, "");
+  if (ROW_HEIGHT_MAP[v] !== void 0) return ROW_HEIGHT_MAP[v];
+  const parsed = parseInt(String(value), 10);
+  return isNaN(parsed) ? 38 : parsed;
+}
+function mapRouteProfile(value) {
+  if (!value || value === "default") return "car";
+  return value;
+}
+
+// src/core/compile/goldenLayout.ts
+function workspaceNodeToGL(node) {
+  const gl = { type: node.type };
+  if ("width" in node && node.width !== void 0) {
+    gl.width = node.width;
+  }
+  if ("height" in node && node.height !== void 0) {
+    gl.height = node.height;
+  }
+  if (node.type === "row" || node.type === "column" || node.type === "stack") {
+    gl.isClosable = true;
+    gl.reorderEnabled = true;
+    gl.title = "";
+    if ("content" in node && node.content) {
+      gl.content = node.content.map(workspaceNodeToGL);
+    }
+    if (node.type === "stack") {
+      gl.activeItemIndex = 0;
+    }
+    return gl;
+  }
+  if (node.type === "component") {
+    const compName = componentToGlName(node.component);
+    if (compName) {
+      gl.componentName = compName;
+    }
+    if (node.title !== void 0) {
+      gl.title = node.title;
+    }
+    gl.isClosable = true;
+    gl.reorderEnabled = true;
+    const compState = {};
+    const compId = node.id;
+    if (compId) {
+      gl.id = compId;
+      compState.id = compId;
+    } else if (compName === "schedulerComponent") {
+      gl.id = "schedulerContainer";
+      compState.id = "scheduler";
+    }
+    if (compName === "datePickerComponent" && compId) {
+      compState.wrapperId = compId;
+    }
+    if (Object.keys(compState).length > 0) {
+      gl.componentState = compState;
+    }
+    return gl;
+  }
+  return gl;
+}
+function detectRootType(workspace) {
+  if (workspace.length === 0) return "row";
+  let heightCount = 0;
+  let widthCount = 0;
+  for (const node of workspace) {
+    if ("height" in node && node.height !== void 0) heightCount++;
+    if ("width" in node && node.width !== void 0) widthCount++;
+  }
+  if (heightCount > widthCount) {
+    return "column";
+  }
+  return "row";
+}
+function workspaceToGoldenLayout(workspace) {
+  const rootType = detectRootType(workspace);
+  return {
+    settings: {
+      hasHeaders: true,
+      constrainDragToContainer: false,
+      reorderEnabled: true,
+      selectionEnabled: true,
+      popoutWholeStack: false,
+      blockedPopoutsThrowError: true,
+      closePopoutsOnUnload: true,
+      showPopoutIcon: false,
+      showMaximiseIcon: true,
+      showCloseIcon: true,
+      responsiveMode: "onload",
+      tabOverlapAllowance: 0,
+      reorderOnTabMenuClick: true,
+      tabControlOffset: 10
+    },
+    dimensions: {
+      borderWidth: 5,
+      borderGrabWidth: 15,
+      minItemHeight: 10,
+      minItemWidth: 10,
+      headerHeight: 20,
+      dragProxyWidth: 300,
+      dragProxyHeight: 200
+    },
+    labels: {
+      close: "Close",
+      maximise: "Maximize",
+      minimise: "Minimize",
+      popout: "open in new window",
+      popin: "pop in",
+      tabDropdown: "Additional Tabs"
+    },
+    content: [
+      {
+        type: rootType,
+        isClosable: true,
+        reorderEnabled: true,
+        title: "",
+        content: workspace.map(workspaceNodeToGL)
+      }
+    ],
+    isClosable: true,
+    reorderEnabled: true,
+    title: "",
+    openPopouts: [],
+    maximisedItemId: null
+  };
+}
+
+// src/core/compile/layoutBuilders/base.ts
+function buildBaseLayoutState(layout, gridName) {
+  const columns = (layout.columns || []).filter((c) => c.property).map((c) => ({ dataIndex: c.property }));
+  const sorters = (layout.sorters || []).filter((s) => s.property && s.direction).map((s) => ({ direction: s.direction, property: s.property }));
+  let grouper;
+  if (layout.grouper && layout.grouper.property && layout.grouper.direction) {
+    grouper = {
+      root: "data",
+      property: layout.grouper.property,
+      direction: layout.grouper.direction,
+      id: layout.grouper.id || layout.grouper.property
+    };
+  }
+  const filters = (layout.filters || []).map((f) => ({
+    operator: f.operator || "like",
+    value: f.value || "",
+    property: f.property,
+    exactMatch: f.exactMatch ?? false
+  }));
+  const pageSize = layout.pageSize !== void 0 ? typeof layout.pageSize === "number" ? layout.pageSize : parseInt(String(layout.pageSize), 10) : 50;
+  const state = {
+    columns,
+    storeState: grouper ? { grouper } : {},
+    filters,
+    Id: layout.id || gridName,
+    pageSize: isNaN(pageSize) ? 50 : pageSize
+  };
+  if (sorters.length > 0) {
+    state.sorters = sorters;
+  }
+  if (layout.default) {
+    state.default = true;
+  }
+  if (layout.name) {
+    state.name = layout.name;
+  }
+  return state;
+}
+
+// src/core/compile/layoutBuilders/scheduler.ts
+function buildSchedulerLayoutState(layout, gridName) {
+  const base = buildBaseLayoutState(layout, gridName);
+  const lockedGridWidth = layout.lockedGridWidth || layout.resourcesGridWidth || null;
+  const fitToScreen = typeof layout.fitToScreen === "boolean" ? layout.fitToScreen : layout.fitToScreen === "true";
+  const ignoreCalendars = typeof layout.ignoreCalendars === "boolean" ? layout.ignoreCalendars : layout.ignoreCalendars === "true";
+  return {
+    ...base,
+    viewPreset: layout.viewPreset !== void 0 ? mapViewPreset(layout.viewPreset) : null,
+    lockedGridWidth,
+    fitToScreen,
+    rowHeight: mapRowHeight(layout.rowHeight),
+    ignoreCalendars
+  };
+}
+
+// src/core/compile/layoutBuilders/capacity.ts
+function buildCapacityLayoutState(layout, gridName) {
+  const base = buildBaseLayoutState(layout, gridName);
+  const state = { ...base };
+  if (layout.viewLayoutType !== void 0) state.viewLayoutType = layout.viewLayoutType;
+  if (layout.startRowGroupsCollapsed !== void 0) state.startRowGroupsCollapsed = layout.startRowGroupsCollapsed;
+  if (layout.startColGroupsCollapsed !== void 0) state.startColGroupsCollapsed = layout.startColGroupsCollapsed;
+  if (layout.enableColumnSort !== void 0) state.enableColumnSort = layout.enableColumnSort;
+  if (layout.expandedItems !== void 0) state.expandedItems = layout.expandedItems;
+  if (layout.matrix !== void 0) state.matrix = layout.matrix;
+  if (layout.pivotcolumns !== void 0) state.pivotcolumns = layout.pivotcolumns;
+  if (layout.collapsed !== void 0) state.collapsed = layout.collapsed;
+  return state;
+}
+
+// src/core/compile/layoutBuilders/gantt.ts
+function buildGanttLayoutState(layout, gridName) {
+  const base = buildBaseLayoutState(layout, gridName);
+  const state = { ...base };
+  if (layout.viewPreset !== void 0) {
+    state.viewPreset = mapViewPreset(layout.viewPreset);
+  }
+  return state;
+}
+
+// src/core/compile/layoutBuilders/grid.ts
+function buildGridLayoutState(layout, gridName) {
+  const base = buildBaseLayoutState(layout, gridName);
+  const state = { ...base };
+  if (layout.hideEmptyRows !== void 0) {
+    state.hideEmptyRows = layout.hideEmptyRows;
+  }
+  return state;
+}
+
+// src/core/compile/layoutBuilders/index.ts
+function buildLayoutState(layout, gridName) {
+  const context = layout.context;
+  switch (context) {
+    case "planningBoard":
+      return buildSchedulerLayoutState(layout, gridName);
+    case "capacity":
+      return buildCapacityLayoutState(layout, gridName);
+    case "gantt":
+      return buildGanttLayoutState(layout, gridName);
+    case "openTasks":
+    case "plannedTasks":
+    case "notifications":
+    case "details":
+    case "routeSequence":
+      return buildGridLayoutState(layout, gridName);
+    default:
+      return buildBaseLayoutState(layout, gridName);
+  }
+}
+
+// src/core/compile/layoutBuilder.ts
+function collectLayouts(layouts) {
+  return layouts.map((layout) => {
+    const gridName = layout.id || layout.code;
+    return {
+      context: layout.context,
+      grid: gridName,
+      value: buildLayoutState(layout, gridName),
+      name: layout.name || layout.code,
+      code: layout.code,
+      componentId: gridName,
+      default: layout.default ?? false,
+      public: layout.shared?.public ?? false,
+      userGroup: layout.shared?.userGroup
+    };
+  });
+}
+function buildLayoutDtos(layouts) {
+  if (!layouts || layouts.length === 0) return [];
+  return collectLayouts(layouts).map((L) => ({
+    context: contextToApiContext(L.context),
+    grid: L.grid,
+    value: JSON.stringify(L.value),
+    default: L.default,
+    public: L.public,
+    userGroup: L.userGroup,
+    isOwner: true,
+    isNew: true,
+    name: L.name,
+    code: L.code
+  }));
+}
+var PANEL_COMPONENTS = /* @__PURE__ */ new Set([
+  "planningBoard",
+  "scheduler",
+  "openTasks",
+  "tasks",
+  "plannedTasks",
+  "details",
+  "gantt",
+  "indicators",
+  "categories",
+  "capacity",
+  "pivot",
+  "notifications",
+  "routeSequence"
+]);
+function buildProfileLayoutDtos(workspace, profileCode) {
+  if (!workspace || workspace.length === 0) return [];
+  const profileLayouts = [];
+  function traverse(nodes) {
+    for (const node of nodes) {
+      if (node.type === "row" || node.type === "column" || node.type === "stack") {
+        if ("content" in node && node.content) {
+          traverse(node.content);
+        }
+      } else if (node.type === "component") {
+        if (node.layoutRef) {
+          const refs = Array.isArray(node.layoutRef) ? node.layoutRef : [node.layoutRef];
+          const needsPanel = PANEL_COMPONENTS.has(node.component);
+          for (const code of refs) {
+            profileLayouts.push({
+              profileCode,
+              layoutCode: code,
+              default: true,
+              public: false,
+              name: node.id ? needsPanel ? `${node.id}_panel` : node.id : ""
+            });
+          }
+        }
+      }
+    }
+  }
+  traverse(workspace);
+  return profileLayouts;
+}
+
+// src/core/compile/profile.ts
+var SNAP_MODE_VALUE = {
+  1: 0,
+  // none
+  2: 3e5,
+  // 5 min
+  3: 6e5,
+  // 10 min
+  4: 9e5,
+  // 15 min
+  5: 18e5,
+  // 30 min
+  6: 36e5,
+  // 1 hour
+  7: 432e5,
+  // 12 hours
+  8: 864e5,
+  // 1 day
+  9: 72e5,
+  // 2 hours
+  10: 144e5
+  // 4 hours
+};
+function getSnapMode(snapInterval) {
+  if (!snapInterval) return void 0;
+  if (typeof snapInterval === "string") return snapInterval;
+  return snapInterval.mode;
+}
+function getSnapValue(snapInterval, snapMode) {
+  if (typeof snapInterval === "object" && snapInterval?.value !== void 0 && snapInterval.value !== null) {
+    return snapInterval.value;
+  }
+  return SNAP_MODE_VALUE[snapMode] ?? 36e5;
+}
+function compileProfileDocument(doc) {
+  const profile = doc.payload;
+  const theme = profile.theme || { color: "default", scheme: "sdtd" };
+  const shared = profile.shared || { global: false, userGroup: "" };
+  const route = profile.route || {
+    profile: "default",
+    calculateRoutes: true,
+    showSequenceIndicators: true,
+    unitOfDistance: "km"
+  };
+  const planning = profile.planning || {
+    snapInterval: { mode: "1hour", value: 0 },
+    range: { mode: "week", value: 0 },
+    start: { mode: "startOfWeek", value: 2 },
+    hours: { start: 8, end: 18 }
+  };
+  const workspace = profile.workspace;
+  const goldenLayout = workspace && workspace.length > 0 ? workspaceToGoldenLayout(workspace) : null;
+  const layouts = [];
+  const profileLayouts = buildProfileLayoutDtos(workspace, profile.code || "");
+  const snapMode = mapSnapMode(getSnapMode(planning.snapInterval));
+  const snapValue = getSnapValue(planning.snapInterval, snapMode);
+  return {
+    id: "profile",
+    payload: {
+      profiles: [{
+        name: profile.name || "",
+        code: profile.code || "",
+        color: theme.color || "default",
+        theme: theme.scheme || "sdtd",
+        public: shared.global ?? false,
+        userGroup: shared.userGroup || "",
+        snapMode,
+        snapValue,
+        rangeMode: mapRangeMode(planning.range?.mode),
+        rangeValue: planning.range?.value ?? null,
+        startMode: mapStartMode(planning.start?.mode),
+        startValue: planning.start?.value ?? null,
+        startTime: planning.hours?.start ?? 8,
+        endTime: planning.hours?.end ?? 18,
+        unitOfDistance: mapUnitOfDistance(route.unitOfDistance),
+        autoRouteCalculation: route.calculateRoutes ?? true,
+        showSequenceIndicators: route.showSequenceIndicators ?? true,
+        routeProfile: mapRouteProfile(route.profile),
+        layout: goldenLayout ? JSON.stringify(goldenLayout) : ""
+      }],
+      layouts,
+      profileLayouts,
+      owner: doc.owner,
+      notificationEmail: doc.notificationEmail
+    }
+  };
+}
+
+// src/core/compile/users.ts
+function compileUsersDocument(doc) {
+  return {
+    id: "users",
+    payload: {
+      users: doc.payload,
+      owner: doc.owner,
+      notificationEmail: doc.notificationEmail
+    }
+  };
+}
+
+// src/core/compile/layouts.ts
+function compileLayoutsDocument(doc) {
+  return {
+    id: "layouts",
+    payload: {
+      layouts: buildLayoutDtos(doc.payload),
+      owner: doc.owner,
+      notificationEmail: doc.notificationEmail
+    }
+  };
+}
+
+// src/core/compile/configuration.ts
+var CONFIG_KEY_TO_INTERNAL = {
+  CompanyName: "AppSetup_CompanyName",
+  CompanyAddress: "AppSetup_CompanyAddress",
+  CompanyAddressCountry: "AppSetup_CompanyAddress_Country",
+  DurationFormat: "AppSetup_DurationFormat",
+  EnableAppointmentContainers: "AppSetup_EnableAppointmentContainers",
+  EnablePlanningBoardTooltip: "AppSetup_EnablePlanningBoardTooltip",
+  ApplyRequestedDates: "AppSetup_ApplyRequestedDates",
+  ApplyRequestedTimes: "AppSetup_ApplyRequestedTimes",
+  RespectAllowedDateConstraints: "AppSetup_RespectAllowedDateConstraints",
+  MultiDayCapacityDistributionMode: "AppSetup_MultiDayCapacityDistributionMode",
+  RenderCategoryInBackground: "AppSetup_RenderCategoryInBackground",
+  AlternateRows: "AppSetup_AlternateRows",
+  EnableResourceCalendarsVisualisation: "AppSetup_EnableResourceCalendarsVisualisation",
+  ResourceZonesColor: "AppSetup_ResourceZonesColor",
+  ResourceCalendarRecalculationMode: "AppSetup_ResourceCalendarRecalculationMode",
+  RouteReschedulingMode: "AppSetup_RouteReschedulingMode",
+  DoNotCountAssignment: "AppSetup_DoNotCountAssignment",
+  DisableTaskDurationCalculation: "AppSetup_DisableTaskDurationCalculation",
+  CalculateRouteAndTravelTime: "AppSetup_CalculateRouteAndTravelTime",
+  DistanceUnit: "AppSetup_DistanceUnit",
+  RouteProfile: "AppSetup_RouteProfile",
+  ShowWaypoints: "AppSetup_ShowWaypoints",
+  MobileVisibilityModeForLockedAppointments: "AppSetup_MobileVisibilityModeForLockedAppointments",
+  SolverApiKey: "AppSetup_SolverApiKey",
+  EnableRouteModel: "AppSetup_EnableRouteModel",
+  EnableFieldServiceModel: "AppSetup_EnableFieldServiceModel",
+  Chat: "AppSetup_Chat",
+  OpenAiApiKey: "AppSetup_OpenAiApiKey",
+  ExchangeClientId: "AppSetup_Exchange_ClientId",
+  ExchangeClientSecret: "AppSetup_Exchange_ClientSecret",
+  ExchangeClientTenant: "AppSetup_Exchange_ClientTenant",
+  ExchangeEnableTwoWaySync: "AppSetup_Exchange_EnableTwoWaySync",
+  ExchangeDeltaStart: "AppSetup_Exchange_DeltaStart",
+  ExchangeDeltaEnd: "AppSetup_Exchange_DeltaEnd",
+  ExchangeResourcePreferencesEnabled: "AppSetup_Exchange_ResourcePreferences_Enabled",
+  ExchangeDefaultShowAs: "AppSetup_Exchange_ResourcePreferences_DefaultShowAs",
+  ExchangeDefaultSensitivity: "AppSetup_Exchange_ResourcePreferences_DefaultSensitivity",
+  ExchangeCategoryPreset: "AppSetup_Exchange_CategoryPreset",
+  ExchangeUseCategory: "AppSetup_Exchange_UseCategory"
+};
+var ENUM_CONVERSIONS = {
+  "AppSetup_DurationFormat": {
+    "Decimal": 0,
+    "HoursMinutes": 1,
+    "DaysDecimal": 2,
+    "DaysHours": 3
+  },
+  "AppSetup_ResourceCalendarRecalculationMode": {
+    "None": 0,
+    "ExtendDuration": 1,
+    "UpdatePlanningQuantity": 2
+  },
+  "AppSetup_DistanceUnit": {
+    "km": 0,
+    "mi": 1
+  },
+  "AppSetup_MobileVisibilityModeForLockedAppointments": {
+    "Locked": 0,
+    "Hidden": 1
+  },
+  "AppSetup_MultiDayCapacityDistributionMode": {
+    "None": 0,
+    "Constant": 1,
+    "Even": 2
+  },
+  "AppSetup_RouteReschedulingMode": {
+    "DoNothing": 0,
+    "UpdateTravelTime": 1,
+    "Optimize": 2
+  }
+};
+var SHOW_AS_TO_ID = {
+  "Free": 1,
+  "Tentative": 2,
+  "Office": 3,
+  "OutOfOffice": 4,
+  "WorkingElsewhere": 5,
+  "Unknown": 6
+};
+var SENSITIVITY_TO_ID = {
+  "Normal": 1,
+  "Personal": 2,
+  "Private": 3,
+  "Confidential": 4
+};
+function convertConfigurationItem(item) {
+  const internalKey = CONFIG_KEY_TO_INTERNAL[item.key] || item.key;
+  let value = item.value;
+  if (internalKey === "AppSetup_Exchange_ResourcePreferences_DefaultShowAs" && Array.isArray(item.value)) {
+    const ids = item.value.map((v) => SHOW_AS_TO_ID[v]).filter(Boolean);
+    value = ids.sort((a, b) => a - b).join(";");
+  } else if (internalKey === "AppSetup_Exchange_ResourcePreferences_DefaultSensitivity" && Array.isArray(item.value)) {
+    const ids = item.value.map((v) => SENSITIVITY_TO_ID[v]).filter(Boolean);
+    value = ids.sort((a, b) => a - b).join(";");
+  } else if (typeof value === "string" && ENUM_CONVERSIONS[internalKey]?.[value] !== void 0) {
+    value = ENUM_CONVERSIONS[internalKey][value];
+  }
+  return {
+    key: internalKey,
+    value
+  };
+}
+function compileConfigurationDocument(doc) {
+  const configuration = (doc.payload || []).map(convertConfigurationItem);
+  return {
+    id: "configuration",
+    payload: {
+      configuration,
+      owner: doc.owner,
+      notificationEmail: doc.notificationEmail
+    }
+  };
+}
+function mergeConfiguration(existing, incoming) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const item of existing) {
+    merged.set(item.key, item);
+  }
+  for (const item of incoming) {
+    merged.set(item.key, item);
+  }
+  return Array.from(merged.values());
+}
+
+// src/core/compile/bundle.ts
+async function resolveBundle(bundle, basePath) {
+  const result = {
+    profiles: [],
+    users: [],
+    layouts: [],
+    configuration: []
+  };
+  const strategy = bundle.mergeStrategy ?? {};
+  for (const item of bundle.documents) {
+    let doc;
+    if (isDocumentReference(item)) {
+      const refPath = resolve(dirname(basePath), item.$ref);
+      const content = await readFile(refPath, "utf-8");
+      const parsed = JSON5.parse(content);
+      if (!isProfileDocument(parsed) && !isUsersDocument(parsed) && !isLayoutsDocument(parsed) && !isConfigurationDocument(parsed)) {
+        throw new Error(`Referenced document at ${item.$ref} is not a valid document type (profile, users, layouts, or configuration)`);
+      }
+      doc = parsed;
+      if (item.$merge) {
+        doc = applyMergeOverrides(doc, item.$merge);
+      }
+    } else if (isProfileDocument(item) || isUsersDocument(item) || isLayoutsDocument(item) || isConfigurationDocument(item)) {
+      doc = item;
+    } else {
+      continue;
+    }
+    if (isProfileDocument(doc)) {
+      result.profiles.push(doc);
+    } else if (isUsersDocument(doc)) {
+      result.users = mergeUsers(result.users, doc.payload ?? [], strategy.users);
+    } else if (isLayoutsDocument(doc)) {
+      result.layouts = mergeLayouts(result.layouts, doc.payload ?? [], strategy.layouts);
+    } else if (isConfigurationDocument(doc)) {
+      result.configuration = mergeConfiguration(result.configuration, doc.payload ?? []);
+    }
+  }
+  return result;
+}
+async function compileBundleDocument(bundle, basePath) {
+  const resolved = await resolveBundle(bundle, basePath);
+  const payloads = [];
+  const strategy = bundle.mergeStrategy ?? {};
+  if (resolved.profiles.length > 0) {
+    let profilesForCompile;
+    if (strategy.profiles === "error" && resolved.profiles.length > 1) {
+      throw new Error(`Multiple profiles found in bundle and mergeStrategy.profiles is 'error'`);
+    } else if (strategy.profiles === "first-wins") {
+      profilesForCompile = [resolved.profiles[0]];
+    } else {
+      profilesForCompile = [resolved.profiles[resolved.profiles.length - 1]];
+    }
+    for (const profile of profilesForCompile) {
+      payloads.push(compileProfileDocument(profile));
+    }
+    if (resolved.layouts.length > 0) {
+      const layoutsDoc = {
+        type: "layouts",
+        payload: resolved.layouts
+      };
+      payloads.push(compileLayoutsDocument(layoutsDoc));
+    }
+  }
+  if (resolved.profiles.length === 0) {
+    if (resolved.users.length > 0) {
+      const usersDoc = {
+        type: "users",
+        payload: resolved.users
+      };
+      payloads.push(compileUsersDocument(usersDoc));
+    }
+    if (resolved.layouts.length > 0) {
+      const layoutsDoc = {
+        type: "layouts",
+        payload: resolved.layouts
+      };
+      payloads.push(compileLayoutsDocument(layoutsDoc));
+    }
+  } else {
+    if (resolved.users.length > 0) {
+      const usersDoc = {
+        type: "users",
+        payload: resolved.users
+      };
+      payloads.push(compileUsersDocument(usersDoc));
+    }
+  }
+  if (resolved.configuration.length > 0) {
+    const configDoc = {
+      type: "configuration",
+      payload: resolved.configuration
+    };
+    payloads.push(compileConfigurationDocument(configDoc));
+  }
+  return {
+    id: "bundle",
+    payloads
+  };
+}
+function compileBundleDocumentSync(bundle) {
+  for (const item of bundle.documents) {
+    if (isDocumentReference(item)) {
+      throw new Error("Bundle contains $ref items. Use compileBundleDocument (async) instead.");
+    }
+  }
+  const result = {
+    profiles: [],
+    users: [],
+    layouts: [],
+    configuration: []
+  };
+  const strategy = bundle.mergeStrategy ?? {};
+  for (const item of bundle.documents) {
+    if (isProfileDocument(item)) {
+      result.profiles.push(item);
+    } else if (isUsersDocument(item)) {
+      result.users = mergeUsers(result.users, item.payload ?? [], strategy.users);
+    } else if (isLayoutsDocument(item)) {
+      result.layouts = mergeLayouts(result.layouts, item.payload ?? [], strategy.layouts);
+    } else if (isConfigurationDocument(item)) {
+      result.configuration = mergeConfiguration(result.configuration, item.payload ?? []);
+    }
+  }
+  const payloads = [];
+  if (result.profiles.length > 0) {
+    let profilesForCompile;
+    if (strategy.profiles === "error" && result.profiles.length > 1) {
+      throw new Error(`Multiple profiles found in bundle and mergeStrategy.profiles is 'error'`);
+    } else if (strategy.profiles === "first-wins") {
+      profilesForCompile = [result.profiles[0]];
+    } else {
+      profilesForCompile = [result.profiles[result.profiles.length - 1]];
+    }
+    for (const profile of profilesForCompile) {
+      payloads.push(compileProfileDocument(profile));
+    }
+    if (result.layouts.length > 0) {
+      payloads.push(compileLayoutsDocument({ type: "layouts", payload: result.layouts }));
+    }
+  }
+  if (result.profiles.length === 0) {
+    if (result.users.length > 0) {
+      payloads.push(compileUsersDocument({ type: "users", payload: result.users }));
+    }
+    if (result.layouts.length > 0) {
+      payloads.push(compileLayoutsDocument({ type: "layouts", payload: result.layouts }));
+    }
+  } else {
+    if (result.users.length > 0) {
+      payloads.push(compileUsersDocument({ type: "users", payload: result.users }));
+    }
+  }
+  if (result.configuration.length > 0) {
+    payloads.push(compileConfigurationDocument({ type: "configuration", payload: result.configuration }));
+  }
+  return {
+    id: "bundle",
+    payloads
+  };
+}
+
+export {
+  isProfileDocument,
+  isUsersDocument,
+  isLayoutsDocument,
+  isConfigurationDocument,
+  isBundleDocument,
+  isDocumentReference,
+  detectDocumentType,
+  compileProfileDocument,
+  compileUsersDocument,
+  compileLayoutsDocument,
+  compileConfigurationDocument,
+  resolveBundle,
+  compileBundleDocument,
+  compileBundleDocumentSync
+};