@timeax/digital-service-engine 0.2.4 → 0.2.5

package/dist/core/index.cjs

@@ -53,6 +53,7 @@ function normalise(input, opts = {}) {
   const excludes_for_buttons = toStringArrayMap(
     obj.excludes_for_buttons
   );
+  const orderKinds = toStringMap(obj.orderKinds);
   const notices = toNoticeArray(obj.notices);
   let filters = rawFilters.map((t) => coerceTag(t, constraints));
   const fields = rawFields.map((f) => coerceField(f, defRole));
@@ -64,6 +65,7 @@ function normalise(input, opts = {}) {
     filters,
     fields,
     order_for_tags: obj.order_for_tags,
+    ...isNonEmpty(orderKinds) && { orderKinds },
     ...isNonEmpty(includes_for_buttons) && { includes_for_buttons },
     ...isNonEmpty(excludes_for_buttons) && { excludes_for_buttons },
     ...fallbacks && (isNonEmpty(fallbacks.nodes) || isNonEmpty(fallbacks.global)) && {
@@ -274,6 +276,15 @@ function normaliseBindId(bind) {
   }
   return void 0;
 }
+function toStringMap(src) {
+  if (!src || typeof src !== "object") return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(src)) {
+    if (!k || typeof v !== "string") continue;
+    out[k] = v;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
 function toStringArrayMap(src) {
   if (!src || typeof src !== "object") return void 0;
   const out = {};
@@ -1092,6 +1103,129 @@ function validateOptionMaps(v) {
   }
 }
 
+// src/utils/order-kind.ts
+function normalizeSelectedTriggerKey(key, nodeMap) {
+  if (!key) return void 0;
+  const compositeIdx = key.indexOf("::");
+  if (compositeIdx !== -1) {
+    const fieldId = key.slice(0, compositeIdx).trim();
+    const optionId = key.slice(compositeIdx + 2).trim();
+    if (optionId) {
+      const optionRef = nodeMap.get(optionId);
+      if ((optionRef == null ? void 0 : optionRef.kind) === "option") {
+        return { nodeId: optionRef.id, nodeKind: "option" };
+      }
+    }
+    if (fieldId) {
+      const fieldRef = nodeMap.get(fieldId);
+      if ((fieldRef == null ? void 0 : fieldRef.kind) === "field") {
+        return { nodeId: fieldRef.id, nodeKind: "field" };
+      }
+    }
+    return void 0;
+  }
+  const ref = nodeMap.get(key);
+  if (!ref) return void 0;
+  if (ref.kind !== "field" && ref.kind !== "option") return void 0;
+  return { nodeId: ref.id, nodeKind: ref.kind };
+}
+function normalizeSelectedOrderKindTriggers(selectedTriggerKeys, nodeMap) {
+  if (!selectedTriggerKeys) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawKey of selectedTriggerKeys) {
+    const key = String(rawKey != null ? rawKey : "");
+    const normalized = normalizeSelectedTriggerKey(key, nodeMap);
+    if (!normalized) continue;
+    const dedupeKey = `${normalized.nodeKind}:${normalized.nodeId}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    out.push(normalized);
+  }
+  return out;
+}
+function resolveOrderKind(params) {
+  var _a, _b;
+  const nodeMap = (_a = params.nodeMap) != null ? _a : buildNodeMap(params.props);
+  const orderKinds = (_b = params.props.orderKinds) != null ? _b : {};
+  const normalizedSelected = normalizeSelectedOrderKindTriggers(
+    params.selectedTriggerKeys,
+    nodeMap
+  );
+  const selectedKindToSource = /* @__PURE__ */ new Map();
+  const selectedNodeIdsForKinds = /* @__PURE__ */ new Map();
+  for (const trigger of normalizedSelected) {
+    const mappedKind = orderKinds[trigger.nodeId];
+    if (typeof mappedKind !== "string") continue;
+    if (!selectedKindToSource.has(mappedKind)) {
+      selectedKindToSource.set(mappedKind, {
+        nodeId: trigger.nodeId,
+        nodeKind: trigger.nodeKind
+      });
+    }
+    if (!selectedNodeIdsForKinds.has(mappedKind)) {
+      selectedNodeIdsForKinds.set(mappedKind, /* @__PURE__ */ new Set());
+    }
+    selectedNodeIdsForKinds.get(mappedKind).add(trigger.nodeId);
+  }
+  const selectedKinds = Array.from(selectedKindToSource.keys());
+  if (selectedKinds.length > 1) {
+    const conflictingNodeIds = Array.from(selectedNodeIdsForKinds.values()).flatMap((ids) => Array.from(ids)).filter((id, idx, arr) => arr.indexOf(id) === idx);
+    return {
+      kind: null,
+      source: null,
+      error: "multiple_order_kinds_selected",
+      conflictingKinds: selectedKinds,
+      conflictingNodeIds
+    };
+  }
+  if (selectedKinds.length === 1) {
+    const selectedKind = selectedKinds[0];
+    return {
+      kind: selectedKind,
+      source: selectedKindToSource.get(selectedKind)
+    };
+  }
+  const activeTagId = params.activeTagId;
+  if (activeTagId) {
+    const tagKind = orderKinds[activeTagId];
+    if (typeof tagKind === "string") {
+      return {
+        kind: tagKind,
+        source: { nodeId: activeTagId, nodeKind: "tag" }
+      };
+    }
+  }
+  return { kind: null, source: null };
+}
+
+// src/core/validate/steps/order-kinds.ts
+function validateOrderKinds(v) {
+  var _a, _b, _c;
+  const selectedTriggerKeys = Array.from((_a = v.selectedKeys) != null ? _a : []);
+  if (!selectedTriggerKeys.length) return;
+  const resolved = resolveOrderKind({
+    props: v.props,
+    selectedTriggerKeys,
+    nodeMap: v.nodeMap
+  });
+  if (resolved.error !== "multiple_order_kinds_selected") return;
+  const conflicts = (_b = resolved.conflictingKinds) != null ? _b : [];
+  const affected = (_c = resolved.conflictingNodeIds) != null ? _c : [];
+  v.errors.push({
+    code: "multiple_order_kinds_selected",
+    severity: "error",
+    message: "Multiple selected triggers resolve to different order kinds. Select triggers that resolve to a single order kind.",
+    details: withAffected(
+      {
+        conflictingKinds: conflicts,
+        conflictingNodeIds: affected
+      },
+      affected
+    )
+  });
+}
+
 // src/core/validate/steps/service-vs-input.ts
 function validateServiceVsUserInput(v) {
   for (const f of v.fields) {
@@ -2420,6 +2554,7 @@ var BuilderImpl = class {
     const out = {
       filters: this.props.filters.slice(),
       fields,
+      ...this.props.orderKinds ? { orderKinds: this.props.orderKinds } : {},
       ...includes_for_buttons && { includes_for_buttons },
       ...excludes_for_buttons && { excludes_for_buttons },
       schema_version: (_e = this.props.schema_version) != null ? _e : "1.0",
@@ -2752,6 +2887,7 @@ function validate(props, ctx = {}) {
   validateStructure(v);
   validateIdentity(v);
   validateOptionMaps(v);
+  validateOrderKinds(v);
   v.fieldsVisibleUnder = createFieldsVisibleUnder(v);
   const visSim = readVisibilitySimOpts(options);
   validateVisibility(v, visSim);
@@ -4152,6 +4288,13 @@ function buildOrderSnapshot(props, builder, selection, services, settings = {})
     fieldById
   );
   const { min, max } = resolveMinMax(servicesList, services);
+  const maybeNodeMap = typeof builder.getNodeMap === "function" ? builder.getNodeMap() : void 0;
+  const resolvedOrderKind = resolveOrderKind({
+    props,
+    activeTagId: tagId,
+    selectedTriggerKeys: selectedButtonKeys,
+    nodeMap: maybeNodeMap
+  });
   const prunedFallbacks = pruneFallbacksConservative(
     props.fallbacks,
     { tagId, constraints: tagConstraints, serviceMap, servicesList },
@@ -4207,6 +4350,8 @@ function buildOrderSnapshot(props, builder, selection, services, settings = {})
     },
     min,
     max: max != null ? max : min,
+    orderKind: resolvedOrderKind.kind,
+    orderKindSource: resolvedOrderKind.source,
     quantity,
     quantitySource,
     services: servicesList,