@timeax/digital-service-engine 0.0.3 → 0.0.4

package/dist/core/index.cjs

@@ -23,8 +23,10 @@ __export(core_exports, {
   buildOrderSnapshot: () => buildOrderSnapshot,
   collectFailedFallbacks: () => collectFailedFallbacks,
   createBuilder: () => createBuilder,
+  createFallbackEditor: () => createFallbackEditor,
   createNodeIndex: () => createNodeIndex,
   getEligibleFallbacks: () => getEligibleFallbacks,
+  getFallbackRegistrationInfo: () => getFallbackRegistrationInfo,
   normalise: () => normalise,
   resolveServiceFallback: () => resolveServiceFallback,
   validate: () => validate,
@@ -2591,6 +2593,10 @@ function getEligibleFallbacks(params) {
   }
   return eligible;
 }
+function getFallbackRegistrationInfo(props, nodeId) {
+  const { primary, tagContexts } = primaryForNode(props, nodeId);
+  return { primary, tagContexts };
+}
 
 // src/core/rate-coherence.ts
 function validateRateCoherenceDeep(params) {
@@ -3821,13 +3827,356 @@ function resolveMinMax(servicesList, services) {
   }
   return { min: min != null ? min : 1, ...max !== void 0 ? { max } : {} };
 }
+
+// src/core/fallback-editor.ts
+function createFallbackEditor(options = {}) {
+  var _a, _b;
+  const original = cloneFallbacks(options.fallbacks);
+  let current = cloneFallbacks(options.fallbacks);
+  const props = options.props;
+  const services = (_a = options.services) != null ? _a : {};
+  const settings = (_b = options.settings) != null ? _b : {};
+  function state() {
+    return {
+      original: cloneFallbacks(original),
+      current: cloneFallbacks(current),
+      changed: !sameFallbacks(original, current)
+    };
+  }
+  function value() {
+    return cloneFallbacks(current);
+  }
+  function reset() {
+    current = cloneFallbacks(original);
+    return state();
+  }
+  function get(serviceId) {
+    var _a2, _b2;
+    const out = [];
+    for (const [primary, list] of Object.entries((_a2 = current.global) != null ? _a2 : {})) {
+      if (String(primary) !== String(serviceId)) continue;
+      out.push({
+        scope: "global",
+        primary,
+        services: [...list != null ? list : []]
+      });
+    }
+    if (!props) return out;
+    for (const [nodeId, list] of Object.entries((_b2 = current.nodes) != null ? _b2 : {})) {
+      const info = getFallbackRegistrationInfo(props, nodeId);
+      if (String(info.primary) !== String(serviceId)) continue;
+      out.push({
+        scope: "node",
+        scopeId: nodeId,
+        primary: info.primary,
+        services: [...list != null ? list : []]
+      });
+    }
+    return out;
+  }
+  function getScope(context) {
+    var _a2, _b2, _c, _d;
+    if (context.scope === "global") {
+      return [...(_b2 = (_a2 = current.global) == null ? void 0 : _a2[context.primary]) != null ? _b2 : []];
+    }
+    return [...(_d = (_c = current.nodes) == null ? void 0 : _c[context.nodeId]) != null ? _d : []];
+  }
+  function check(context, candidates) {
+    var _a2, _b2;
+    const normalized = normalizeCandidateList(
+      candidates != null ? candidates : getScope(context),
+      true
+    );
+    if (context.scope === "node" && !props) {
+      return {
+        context,
+        allowed: [],
+        rejected: normalized.map((candidate) => ({
+          candidate,
+          ok: false,
+          reasons: ["missing_service_props"]
+        })),
+        warnings: ["missing_service_props"]
+      };
+    }
+    const tempFallbacks = cloneFallbacks(current);
+    if (context.scope === "global") {
+      (_a2 = tempFallbacks.global) != null ? _a2 : tempFallbacks.global = {};
+      if (normalized.length)
+        tempFallbacks.global[context.primary] = normalized;
+      else delete tempFallbacks.global[context.primary];
+    } else {
+      (_b2 = tempFallbacks.nodes) != null ? _b2 : tempFallbacks.nodes = {};
+      if (normalized.length)
+        tempFallbacks.nodes[context.nodeId] = normalized;
+      else delete tempFallbacks.nodes[context.nodeId];
+    }
+    if (!props) {
+      if (context.scope !== "global") {
+        return {
+          context,
+          allowed: [],
+          rejected: normalized.map((candidate) => ({
+            candidate,
+            ok: false,
+            reasons: ["missing_service_props"]
+          })),
+          warnings: ["missing_service_props"]
+        };
+      }
+      const rejected2 = [];
+      const allowed2 = [];
+      for (const candidate of normalized) {
+        const reasons = [];
+        if (String(candidate) === String(context.primary)) {
+          reasons.push("self_reference");
+        }
+        if (reasons.length) {
+          rejected2.push({ candidate, ok: false, reasons });
+        } else {
+          allowed2.push(candidate);
+        }
+      }
+      return {
+        context,
+        primary: context.primary,
+        allowed: allowed2,
+        rejected: rejected2,
+        warnings: []
+      };
+    }
+    const fakeProps = {
+      ...props,
+      fallbacks: tempFallbacks
+    };
+    const diags = collectFailedFallbacks(fakeProps, services, {
+      ...settings,
+      mode: "dev"
+    });
+    const scoped = diags.filter((d) => {
+      if (context.scope === "global") {
+        return d.scope === "global" && String(d.primary) === String(context.primary);
+      }
+      return d.scope === "node" && String(d.nodeId) === String(context.nodeId);
+    });
+    const rejected = normalized.map((candidate) => {
+      const reasons = scoped.filter((d) => String(d.candidate) === String(candidate)).map((d) => mapDiagReason(d.reason));
+      return {
+        candidate,
+        ok: reasons.length === 0,
+        reasons
+      };
+    }).filter((row) => !row.ok);
+    const allowed = normalized.filter(
+      (candidate) => !rejected.some(
+        (r) => String(r.candidate) === String(candidate)
+      )
+    );
+    const info = context.scope === "global" ? { ok: true, primary: context.primary } : getNodeRegistrationInfo(props, context.nodeId);
+    const primary = (info == null ? void 0 : info.ok) ? info.primary : void 0;
+    return {
+      context,
+      primary,
+      allowed,
+      rejected,
+      warnings: []
+    };
+  }
+  function add(context, candidate, options2) {
+    return addMany(context, [candidate], options2);
+  }
+  function addMany(context, candidates, options2) {
+    const existing = getScope(context);
+    const merged = [...existing];
+    const insertAt = typeof (options2 == null ? void 0 : options2.index) === "number" ? clamp(options2.index, 0, merged.length) : void 0;
+    const incoming = normalizeCandidateList(candidates, true).filter(
+      (id) => !merged.some((x) => String(x) === String(id))
+    );
+    if (insertAt === void 0) {
+      merged.push(...incoming);
+    } else {
+      merged.splice(insertAt, 0, ...incoming);
+    }
+    return replace(context, merged, options2);
+  }
+  function remove(context, candidate) {
+    const next = getScope(context).filter(
+      (id) => String(id) !== String(candidate)
+    );
+    return writeScope(context, next);
+  }
+  function replace(context, candidates, options2) {
+    const strict = !!(options2 == null ? void 0 : options2.strict);
+    const normalized = normalizeCandidateList(candidates, true);
+    const checked = check(context, normalized);
+    const next = strict ? checked.allowed : normalized;
+    return writeScope(context, next);
+  }
+  function clear(context) {
+    return writeScope(context, []);
+  }
+  function eligible(context, opt) {
+    if (!props) return [];
+    if (context.scope === "global") {
+      return getEligibleFallbacks({
+        primary: context.primary,
+        services,
+        fallbacks: current,
+        settings,
+        props,
+        exclude: opt == null ? void 0 : opt.exclude,
+        unique: opt == null ? void 0 : opt.unique,
+        limit: opt == null ? void 0 : opt.limit
+      });
+    }
+    const info = getFallbackRegistrationInfo(props, context.nodeId);
+    if (!info.primary) return [];
+    return getEligibleFallbacks({
+      primary: info.primary,
+      nodeId: context.nodeId,
+      tagId: info.tagContexts[0],
+      services,
+      fallbacks: current,
+      settings,
+      props,
+      exclude: opt == null ? void 0 : opt.exclude,
+      unique: opt == null ? void 0 : opt.unique,
+      limit: opt == null ? void 0 : opt.limit
+    });
+  }
+  function writeScope(context, nextList) {
+    var _a2, _b2;
+    const next = cloneFallbacks(current);
+    if (context.scope === "global") {
+      (_a2 = next.global) != null ? _a2 : next.global = {};
+      if (nextList.length) {
+        next.global[context.primary] = [...nextList];
+      } else {
+        delete next.global[context.primary];
+        if (!Object.keys(next.global).length) delete next.global;
+      }
+    } else {
+      (_b2 = next.nodes) != null ? _b2 : next.nodes = {};
+      if (nextList.length) {
+        next.nodes[context.nodeId] = [...nextList];
+      } else {
+        delete next.nodes[context.nodeId];
+        if (!Object.keys(next.nodes).length) delete next.nodes;
+      }
+    }
+    current = next;
+    return state();
+  }
+  return {
+    state,
+    value,
+    reset,
+    get,
+    getScope,
+    check,
+    add,
+    addMany,
+    remove,
+    replace,
+    clear,
+    eligible
+  };
+}
+function cloneFallbacks(input) {
+  return {
+    ...(input == null ? void 0 : input.nodes) ? { nodes: cloneRecordArray(input.nodes) } : {},
+    ...(input == null ? void 0 : input.global) ? { global: cloneRecordArray(input.global) } : {}
+  };
+}
+function cloneRecordArray(input) {
+  const out = {};
+  for (const [k, v] of Object.entries(input)) out[k] = [...v != null ? v : []];
+  return out;
+}
+function sameFallbacks(a, b) {
+  return JSON.stringify(a != null ? a : {}) === JSON.stringify(b != null ? b : {});
+}
+function normalizeCandidateList(input, preserveOrder) {
+  const out = [];
+  for (const item of input != null ? input : []) {
+    if (!isValidServiceIdRef(item)) continue;
+    const exists = out.some((x) => String(x) === String(item));
+    if (exists) continue;
+    out.push(item);
+  }
+  return preserveOrder ? out : out;
+}
+function isValidServiceIdRef(value) {
+  return typeof value === "number" && Number.isFinite(value) || typeof value === "string" && value.trim().length > 0;
+}
+function clamp(n, min, max) {
+  return Math.max(min, Math.min(max, n));
+}
+function getNodeRegistrationInfo(props, nodeId) {
+  const tag = props.filters.find((t) => t.id === nodeId);
+  if (tag) {
+    if (!isValidServiceIdRef(tag.service_id)) {
+      return { ok: false, reasons: ["no_primary"] };
+    }
+    return {
+      ok: true,
+      primary: tag.service_id,
+      tagContexts: [tag.id]
+    };
+  }
+  const hit = findOptionOwner(props.fields, nodeId);
+  if (!hit) {
+    return { ok: false, reasons: ["node_not_found"] };
+  }
+  if (!isValidServiceIdRef(hit.option.service_id)) {
+    return { ok: false, reasons: ["no_primary"] };
+  }
+  return {
+    ok: true,
+    primary: hit.option.service_id,
+    tagContexts: bindIdsToArray2(hit.field.bind_id)
+  };
+}
+function findOptionOwner(fields, optionId) {
+  var _a;
+  for (const field of fields) {
+    for (const option of (_a = field.options) != null ? _a : []) {
+      if (option.id === optionId) return { field, option };
+    }
+  }
+  return null;
+}
+function bindIdsToArray2(v) {
+  if (Array.isArray(v)) return v.filter(Boolean);
+  return v ? [v] : [];
+}
+function mapDiagReason(reason) {
+  switch (String(reason)) {
+    case "unknown_service":
+      return "unknown_service";
+    case "no_primary":
+      return "no_primary";
+    case "rate_violation":
+      return "rate_violation";
+    case "constraint_mismatch":
+      return "constraint_mismatch";
+    case "cycle":
+      return "cycle";
+    case "no_tag_context":
+      return "no_tag_context";
+    default:
+      return "node_not_found";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildOrderSnapshot,
   collectFailedFallbacks,
   createBuilder,
+  createFallbackEditor,
   createNodeIndex,
   getEligibleFallbacks,
+  getFallbackRegistrationInfo,
   normalise,
   resolveServiceFallback,
   validate,