@prorobotech/openapi-k8s-toolkit 0.0.1-alpha.139 → 0.0.1-alpha.140

package/dist/openapi-k8s-toolkit.es.js

@@ -47861,14 +47861,16 @@ const materializeAdditionalFromValues = (props, values, blockedPathsRef) => {
   return { props: next, toExpand, toPersist };
 };
 
-const DEBUG_PREFILLS = false;
 const dbg = (...args) => {
+  console.log("[prefill]", ...args);
 };
-const group = (label) => DEBUG_PREFILLS;
-const DEBUG_WILDCARDS = false;
+const group = (label) => console.groupCollapsed("[prefill]", label);
+const end = () => console.groupEnd();
 const wdbg = (...args) => {
+  console.log("[wildcards]", ...args);
 };
-const wgroup = (label) => DEBUG_WILDCARDS;
+const wgroup = (label) => console.groupCollapsed("[wildcards]", label);
+const wend = () => console.groupEnd();
 const prettyPath = (arr) => arr.map((s) => s === "*" ? "*" : String(s)).join(".");
 
 const pathKey = (p) => JSON.stringify(p);
@@ -47885,6 +47887,7 @@ const collectArrayLengths = (obj, base = [], out = /* @__PURE__ */ new Map()) =>
 const templateMatchesArray = (tpl, arrayPath) => {
   const w = tpl.wildcardPath;
   if (w.length < arrayPath.length + 1) {
+    dbg("⛔ length too short to match", { w, arrayPath });
     return false;
   }
   for (let i = 0; i < arrayPath.length; i++) {
@@ -47904,8 +47907,21 @@ const buildConcretePathForNewItem = (tpl, arrayPath, newIndex) => {
     realizedPrefix.push(w[i] === "*" ? arrayPath[i] : w[i]);
   }
   const result = [...realizedPrefix, newIndex, ...w.slice(arrayPath.length + 1)];
+  dbg("→ concrete path", { wildcard: w, arrayPath, newIndex, realizedPrefix, result });
   return result;
 };
+const scrubLiteralWildcardKeys = (input) => {
+  if (Array.isArray(input)) return input.map(scrubLiteralWildcardKeys);
+  if (_$1.isPlainObject(input)) {
+    const out = {};
+    Object.entries(input).forEach(([k, v]) => {
+      if (k === "*") return;
+      out[k] = scrubLiteralWildcardKeys(v);
+    });
+    return out;
+  }
+  return input;
+};
 
 const sanitizeWildcardPath = (p) => {
   const out = p.map((seg) => {
@@ -47914,6 +47930,7 @@ const sanitizeWildcardPath = (p) => {
     if (typeof seg === "string") return /^\d+$/.test(seg) ? "*" : seg;
     return "*";
   });
+  wdbg("sanitize →", p, "=>", out);
   return out;
 };
 const isPlainObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
@@ -47940,22 +47957,31 @@ const expandOneTemplate = (tpl, node, base = [], out = []) => {
         }
       } else if (isPlainObj(curr)) {
         const keys = Object.keys(curr);
+        wdbg("  wildcard over object keys", keys);
         for (const k of keys) {
           step(i + 1, curr[k], [...path, k]);
         }
-      } else ;
+      } else {
+        wdbg("  wildcard dead-end (not array/object)");
+      }
       return;
     }
     if (isPlainObj(curr) && seg in curr) {
+      wdbg("  descend object key", seg);
       step(i + 1, curr[seg], [...path, seg]);
     } else if (Array.isArray(curr) && typeof seg === "number" && curr[seg] !== void 0) {
+      wdbg("  descend array index", seg);
       step(i + 1, curr[seg], [...path, seg]);
-    } else ;
+    } else {
+      wdbg("  dead-end at concrete seg", seg);
+    }
   };
   step(0, node, base);
+  wend();
   return out;
 };
-const expandWildcardTemplates = (templates, values) => {
+const expandWildcardTemplates = (templates, values, opts) => {
+  wgroup("expand templates");
   templates.forEach((t, i) => wdbg(`#${i}`, prettyPath(t)));
   const acc = [];
   const seen = /* @__PURE__ */ new Set();
@@ -47968,8 +47994,17 @@ const expandWildcardTemplates = (templates, values) => {
         acc.push(p);
       }
     }
+    if (!hits.length && opts?.includeMissingExact && !tpl.some((seg) => seg === "*")) {
+      const k = JSON.stringify(tpl);
+      if (!seen.has(k)) {
+        wdbg('no hits; include exact (no "*") →', prettyPath(tpl));
+        seen.add(k);
+        acc.push(tpl);
+      }
+    }
   }
   wdbg("expanded →", acc.map(prettyPath));
+  wend();
   return acc;
 };
 const isPathArray = (p) => Array.isArray(p);
@@ -48112,7 +48147,8 @@ const BlackholeForm = ({
       setError(void 0);
       const name = form.getFieldValue(["metadata", "name"]);
       const namespace = form.getFieldValue(["metadata", "namespace"]);
-      const values = form.getFieldsValue();
+      const valuesRaw = form.getFieldsValue();
+      const values = scrubLiteralWildcardKeys(valuesRaw);
       const payload = {
         values,
         persistedKeys,
@@ -48185,7 +48221,10 @@ const BlackholeForm = ({
     }
     if (formsPrefills) {
       formsPrefills.spec.values.forEach(({ path, value }) => {
-        _$1.set(allValues, path, value);
+        const hasWildcard = path.some((seg) => seg === "*");
+        if (!hasWildcard) {
+          _$1.set(allValues, path, value);
+        }
       });
     }
     if (prefillValueNamespaceOnly) {
@@ -48215,7 +48254,8 @@ const BlackholeForm = ({
     return templates.sort((a, b) => b.wildcardPath.length - a.wildcardPath.length);
   }, [formsPrefills, normalizedPrefill]);
   useEffect(() => {
-    return;
+    dbg("templates (wildcards, ordered specific→generic):");
+    prefillTemplates.forEach((t, i) => dbg(`#${i}`, t.wildcardPath.join("."), "=>", t.value));
   }, [prefillTemplates]);
   const prevArrayLengthsRef = useRef(/* @__PURE__ */ new Map());
   const applyPrefillForNewArrayItem = useCallback(
@@ -48227,31 +48267,47 @@ const BlackholeForm = ({
         if (!matches) continue;
         const concretePath = buildConcretePathForNewItem(tpl, arrayPath, newIndex);
         const current = form.getFieldValue(concretePath);
+        dbg("current value at path", concretePath, ":", current);
         if (typeof current === "undefined") {
           const toSet = _$1.cloneDeep(tpl.value);
+          dbg("setting value", { path: concretePath, value: toSet });
           form.setFieldValue(concretePath, toSet);
+        } else {
+          dbg("skipping set (already has value)");
         }
       }
+      end();
     },
     [form, prefillTemplates]
   );
   const hiddenWildcardTemplates = useMemo(() => {
     const raw = hiddenPaths ?? [];
+    wgroup("hidden raw templates");
     raw.forEach((p, i) => wdbg(`#${i}`, p));
+    wend();
     const sanitized = raw.map((p) => sanitizeWildcardPath(p));
+    wgroup("hidden sanitized templates");
     sanitized.forEach((p, i) => wdbg(`#${i}`, prettyPath(p)));
+    wend();
     return sanitized;
   }, [hiddenPaths]);
   const expandedWildcardTemplates = useMemo(() => {
     const raw = expandedPaths ?? [];
+    wgroup("expanded raw templates");
     raw.forEach((p, i) => wdbg(`#${i}`, p));
+    wend();
     const sanitized = raw.map((p) => sanitizeWildcardPath(p));
+    wgroup("expanded sanitized templates");
     sanitized.forEach((p, i) => wdbg(`#${i}`, prettyPath(p)));
+    wend();
     return sanitized;
   }, [expandedPaths]);
   useEffect(() => {
     if (!initialValues) return;
-    const hiddenResolved = expandWildcardTemplates(hiddenWildcardTemplates, initialValues);
+    wgroup("initial resolve");
+    const hiddenResolved = expandWildcardTemplates(hiddenWildcardTemplates, initialValues, {
+      includeMissingExact: true
+    });
     wdbg("hidden resolved", hiddenResolved.map(prettyPath));
     setResolvedHiddenPaths(hiddenResolved);
     const expandedResolved = expandWildcardTemplates(expandedWildcardTemplates, initialValues);
@@ -48268,6 +48324,7 @@ const BlackholeForm = ({
       }
       return merged;
     });
+    wend();
   }, [initialValues, hiddenWildcardTemplates, expandedWildcardTemplates]);
   const resolvedHiddenStringPaths = useMemo(
     () => resolvedHiddenPaths.map(toStringPath),
@@ -48294,8 +48351,15 @@ const BlackholeForm = ({
   }, 300);
   const onValuesChangeCallback = useCallback(
     (values) => {
-      const v = values ?? form.getFieldsValue(true);
-      const hiddenResolved = expandWildcardTemplates(hiddenWildcardTemplates, v);
+      const vRaw = values ?? form.getFieldsValue(true);
+      const v = scrubLiteralWildcardKeys(vRaw);
+      wgroup("values→resolve wildcards");
+      const hiddenResolved = expandWildcardTemplates(
+        hiddenWildcardTemplates,
+        v,
+        { includeMissingExact: true }
+        // only hidden opts in
+      );
       wdbg("hidden resolved", hiddenResolved.map(prettyPath));
       setResolvedHiddenPaths(hiddenResolved);
       const expandedResolved = expandWildcardTemplates(expandedWildcardTemplates, v);
@@ -48314,20 +48378,27 @@ const BlackholeForm = ({
           return merged;
         });
       }
+      wend();
+      group("values change");
+      dbg("values snapshot keys", Object.keys(v || {}));
       const newLengths = collectArrayLengths(v);
       const prevLengths = prevArrayLengthsRef.current;
+      dbg("array lengths (prev → new)");
       const allKeys = /* @__PURE__ */ new Set([...prevLengths.keys(), ...newLengths.keys()]);
       [...allKeys].forEach((k) => dbg(k, " : ", prevLengths.get(k), "→", newLengths.get(k)));
       for (const [k, newLen] of newLengths.entries()) {
         const prevLen = prevLengths.get(k) ?? 0;
         if (newLen > prevLen) {
           const arrayPath = JSON.parse(k);
+          dbg("🟢 detected growth", { pathKey: k, arrayPath, prevLen, newLen });
           for (let i = prevLen; i < newLen; i++) {
+            dbg("…prefilling new index", i, "under", arrayPath);
             applyPrefillForNewArrayItem(arrayPath, i);
           }
         }
       }
       prevArrayLengthsRef.current = newLengths;
+      end();
       const payload = {
         values: v,
         persistedKeys,