@o3co/ts.hocon 1.4.1 → 1.5.2

package/dist/index.cjs

@@ -338,6 +338,192 @@ function mergeUnresolved(receiver, fallback) {
   return result;
 }
 
+// src/internal/resolver/fold-self-ref.ts
+function substFullKey(s) {
+  return stringSegmentsToKey(s.segments.map((seg) => seg.text));
+}
+function stringSegmentsToKey(segments) {
+  return segments.map((t) => {
+    if (t === "" || /[^a-zA-Z0-9\-_]/.test(t)) {
+      return `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return t;
+  }).join(".");
+}
+function containsSelfRef(v, fullKey) {
+  if (isSubst(v)) return substFullKey(v) === fullKey;
+  if (isConcat(v)) return v.nodes.some((n) => containsSelfRef(n, fullKey));
+  if (isAppend(v)) {
+    return containsSelfRef(v.existing, fullKey) || containsSelfRef(v.elem, fullKey);
+  }
+  if (isResObj(v)) {
+    for (const f of v.fields.values()) {
+      if (containsSelfRef(f, fullKey)) return true;
+    }
+    return false;
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return hv.items.some((item) => containsSelfRef(item, fullKey));
+  }
+  if (hv.kind === "object") {
+    for (const f of hv.fields.values()) {
+      if (containsSelfRef(f, fullKey)) return true;
+    }
+    return false;
+  }
+  return false;
+}
+function foldSelfRef(v, fullKey, replacement) {
+  if (isSubst(v)) {
+    return substFullKey(v) === fullKey ? replacement : v;
+  }
+  if (isConcat(v)) {
+    return {
+      _kind: "concat-placeholder",
+      nodes: v.nodes.map((n) => foldSelfRef(n, fullKey, replacement)),
+      line: v.line,
+      col: v.col
+    };
+  }
+  if (isAppend(v)) {
+    return {
+      _kind: "append-placeholder",
+      existing: foldSelfRef(v.existing, fullKey, replacement),
+      elem: foldSelfRef(v.elem, fullKey, replacement)
+    };
+  }
+  if (isResObj(v)) {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.fields) {
+      newFields.set(k, foldSelfRef(val, fullKey, replacement));
+    }
+    return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues) };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return {
+      kind: "array",
+      items: hv.items.map((item) => foldSelfRef(item, fullKey, replacement))
+    };
+  }
+  if (hv.kind === "object") {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of hv.fields) {
+      newFields.set(k, foldSelfRef(val, fullKey, replacement));
+    }
+    return { kind: "object", fields: newFields };
+  }
+  return v;
+}
+function foldOrSkipPrior(prior, fullKey, old) {
+  if (!containsSelfRef(prior, fullKey)) return cloneResolverValue(prior);
+  if (old === void 0) return void 0;
+  return foldSelfRef(prior, fullKey, old);
+}
+function cloneResolverValue(v) {
+  if (isSubst(v)) {
+    return {
+      _kind: "subst-placeholder",
+      segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
+      optional: v.optional,
+      listSuffix: v.listSuffix,
+      line: v.line,
+      col: v.col,
+      prefixLen: v.prefixLen
+    };
+  }
+  if (isConcat(v)) {
+    return {
+      _kind: "concat-placeholder",
+      nodes: v.nodes.map((n) => cloneResolverValue(n)),
+      line: v.line,
+      col: v.col
+    };
+  }
+  if (isResObj(v)) {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.fields) newFields.set(k, cloneResolverValue(val));
+    const newPriors = /* @__PURE__ */ new Map();
+    for (const [k, val] of v.priorValues) newPriors.set(k, cloneResolverValue(val));
+    return { _kind: "res-obj", fields: newFields, priorValues: newPriors };
+  }
+  if (isAppend(v)) {
+    return {
+      _kind: "append-placeholder",
+      existing: cloneResolverValue(v.existing),
+      elem: cloneResolverValue(v.elem)
+    };
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return {
+      kind: "array",
+      items: hv.items.map((item) => cloneResolverValue(item))
+    };
+  }
+  if (hv.kind === "object") {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, val] of hv.fields) {
+      newFields.set(k, cloneResolverValue(val));
+    }
+    return { kind: "object", fields: newFields };
+  }
+  return hv;
+}
+function foldNestedSelfRefs(v, pathPrefix) {
+  if (!isResObj(v)) return v;
+  const newFields = /* @__PURE__ */ new Map();
+  for (const [k, fieldVal] of v.fields) {
+    const childPath = [...pathPrefix, k];
+    const fullKey = stringSegmentsToKey(childPath);
+    const folded = foldNestedSelfRefs(fieldVal, childPath);
+    let finalVal = folded;
+    if (containsSelfRef(folded, fullKey)) {
+      const leafPrior = v.priorValues.get(k);
+      if (leafPrior !== void 0) {
+        const leafPriorFolded = foldNestedSelfRefs(leafPrior, childPath);
+        finalVal = foldSelfRef(folded, fullKey, leafPriorFolded);
+      }
+    }
+    newFields.set(k, finalVal);
+  }
+  return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues) };
+}
+function containsSubstByPath(v, target) {
+  if (isSubst(v)) return segmentsTextEqual(v.segments, target);
+  if (isConcat(v)) return v.nodes.some((n) => containsSubstByPath(n, target));
+  if (isAppend(v)) {
+    return containsSubstByPath(v.existing, target) || containsSubstByPath(v.elem, target);
+  }
+  if (isResObj(v)) {
+    for (const f of v.fields.values()) {
+      if (containsSubstByPath(f, target)) return true;
+    }
+    return false;
+  }
+  const hv = v;
+  if (hv.kind === "array") {
+    return hv.items.some((item) => containsSubstByPath(item, target));
+  }
+  if (hv.kind === "object") {
+    for (const f of hv.fields.values()) {
+      if (containsSubstByPath(f, target)) return true;
+    }
+    return false;
+  }
+  return false;
+}
+function segmentsTextEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    if (ai === void 0 || bi === void 0 || ai.text !== bi.text) return false;
+  }
+  return true;
+}
+
 // src/internal/resolver/utils.ts
 function segmentsToKey(segments) {
   return segments.map((s) => {
@@ -379,13 +565,22 @@ function deepMergeHoconValues(base, overlay) {
   }
   return { kind: "object", fields: merged };
 }
-function deepMergeResObjInto(dst, src) {
+function deepMergeResObjInto(dst, src, pathPrefix = []) {
   for (const [k, srcVal] of src.fields) {
+    const childPrefix = [...pathPrefix, k];
+    const fullKey = stringSegmentsToKey(childPrefix);
     const dstVal = dst.fields.get(k);
     if (dstVal !== void 0 && isResObj(dstVal) && isResObj(srcVal)) {
-      deepMergeResObjInto(dstVal, srcVal);
+      const priorExisting = dst.priorValues.get(k);
+      const prior = foldOrSkipPrior(dstVal, fullKey, priorExisting);
+      if (prior !== void 0) dst.priorValues.set(k, prior);
+      deepMergeResObjInto(dstVal, srcVal, childPrefix);
     } else {
-      if (dstVal !== void 0) dst.priorValues.set(k, dstVal);
+      if (dstVal !== void 0) {
+        const priorExisting = dst.priorValues.get(k);
+        const prior = foldOrSkipPrior(dstVal, fullKey, priorExisting);
+        if (prior !== void 0) dst.priorValues.set(k, prior);
+      }
       dst.fields.set(k, srcVal);
     }
   }
@@ -949,12 +1144,17 @@ var Parser = class {
     const segments = [];
     let trailingDot = false;
     let firstWasQuoted = false;
+    let spaceConcat = false;
     while (true) {
       const t = this.peek();
       if (t.kind === "string") {
         this.advance();
         if (segments.length === 0) firstWasQuoted = true;
-        segments.push(t.value);
+        if (spaceConcat) {
+          segments[segments.length - 1] = `${segments[segments.length - 1]} ${t.value}`;
+        } else {
+          segments.push(t.value);
+        }
         trailingDot = false;
       } else if (t.kind === "unquoted") {
         this.advance();
@@ -971,12 +1171,23 @@ var Parser = class {
             );
           }
         }
-        segments.push(...filtered);
+        if (spaceConcat && filtered.length > 0) {
+          if (raw.startsWith(".")) {
+            segments.push(...filtered);
+          } else {
+            const [head, ...tail] = filtered;
+            segments[segments.length - 1] = `${segments[segments.length - 1]} ${head}`;
+            segments.push(...tail);
+          }
+        } else {
+          segments.push(...filtered);
+        }
         trailingDot = raw.endsWith(".");
       } else {
         if (segments.length === 0) throw new ParseError(`expected key, got ${t.kind}`, t.line, t.col);
         break;
       }
+      spaceConcat = false;
       if (trailingDot) continue;
       const next = this.peek();
       if (next.kind === "unquoted" && next.value === "." && !next.precedingSpace) {
@@ -988,6 +1199,10 @@ var Parser = class {
         trailingDot = true;
         continue;
       }
+      if ((next.kind === "unquoted" || next.kind === "string") && next.precedingSpace) {
+        spaceConcat = true;
+        continue;
+      }
       break;
     }
     return { segments, firstWasQuoted };
@@ -1376,7 +1591,7 @@ var IncludeLoader = class {
     for (const ext of probeExts) {
       const obj = this.loadSingle(`${absPath}${ext}`);
       if (obj !== void 0) {
-        deepMergeResObjInto(merged, obj);
+        deepMergeResObjInto(merged, obj, []);
         foundAny = true;
       }
     }
@@ -1409,7 +1624,7 @@ var IncludeLoader = class {
     for (const ext of probeExts) {
       const obj = await this.loadSingleAsync(`${absPath}${ext}`);
       if (obj !== void 0) {
-        deepMergeResObjInto(merged, obj);
+        deepMergeResObjInto(merged, obj, []);
         foundAny = true;
       }
     }
@@ -1581,7 +1796,7 @@ var StructureBuilder = class _StructureBuilder {
       if (pathPrefix.length > 0) {
         this.relativizeResObj(included, pathPrefix);
       }
-      deepMergeResObjInto(obj, included);
+      deepMergeResObjInto(obj, included, pathPrefix);
       return;
     }
     const [head, ...tail] = field.key;
@@ -1596,12 +1811,27 @@ var StructureBuilder = class _StructureBuilder {
       return;
     }
     const childPrefix = [...pathPrefix, head];
+    const fullKey = stringSegmentsToKey(childPrefix);
     if (field.append) {
       const existing2 = obj.fields.get(head) ?? { kind: "array", items: [] };
-      obj.priorValues.set(head, existing2);
+      const oldPrior = obj.priorValues.get(head);
+      const folded = foldOrSkipPrior(existing2, fullKey, oldPrior);
+      if (folded !== void 0) obj.priorValues.set(head, folded);
       obj.fields.set(head, {
         _kind: "append-placeholder",
-        existing: existing2,
+        // Use the folded existing (self-ref-free) for the Append. When the
+        // fold returned undefined (self-ref present but no old prior),
+        // fall back to the original existing — resolveSubst will then
+        // raise the "self-ref with no prior value" error at resolve time,
+        // matching the pre-fix behaviour for that edge case.
+        //
+        // Clone `folded` again so the Append.existing and priorValues[head]
+        // do not share the same Subst/Concat references — relativizeResObj
+        // walks BOTH `fields` and `priorValues` and mutates Subst.segments
+        // in place, so a shared reference would get its prefix applied
+        // twice (resulting in e.g. `${outer.outer.base}` instead of
+        // `${outer.base}`). Codex review on PR #131.
+        existing: folded !== void 0 ? cloneResolverValue(folded) : existing2,
         elem: this.astToResolverValue(field.value, childPrefix)
       });
       return;
@@ -1609,10 +1839,13 @@ var StructureBuilder = class _StructureBuilder {
     const existing = obj.fields.get(head);
     const newVal = this.astToResolverValue(field.value, childPrefix);
     if (existing !== void 0) {
-      obj.priorValues.set(head, existing);
+      const exFolded = foldNestedSelfRefs(existing, childPrefix);
+      const oldPrior = obj.priorValues.get(head);
+      const prior = foldOrSkipPrior(exFolded, fullKey, oldPrior);
+      if (prior !== void 0) obj.priorValues.set(head, prior);
     }
     if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
-      deepMergeResObjInto(existing, newVal);
+      deepMergeResObjInto(existing, newVal, childPrefix);
       return;
     }
     obj.fields.set(head, newVal);
@@ -1629,7 +1862,7 @@ var StructureBuilder = class _StructureBuilder {
       if (pathPrefix.length > 0) {
         this.relativizeResObj(included, pathPrefix);
       }
-      deepMergeResObjInto(obj, included);
+      deepMergeResObjInto(obj, included, pathPrefix);
       return;
     }
     const [head, ...tail] = field.key;
@@ -1644,12 +1877,15 @@ var StructureBuilder = class _StructureBuilder {
       return;
     }
     const childPrefix = [...pathPrefix, head];
+    const fullKey = stringSegmentsToKey(childPrefix);
     if (field.append) {
       const existing2 = obj.fields.get(head) ?? { kind: "array", items: [] };
-      obj.priorValues.set(head, existing2);
+      const oldPrior = obj.priorValues.get(head);
+      const folded = foldOrSkipPrior(existing2, fullKey, oldPrior);
+      if (folded !== void 0) obj.priorValues.set(head, folded);
       obj.fields.set(head, {
         _kind: "append-placeholder",
-        existing: existing2,
+        existing: folded !== void 0 ? cloneResolverValue(folded) : existing2,
         elem: await this.astToResolverValueAsync(field.value, childPrefix)
       });
       return;
@@ -1657,10 +1893,13 @@ var StructureBuilder = class _StructureBuilder {
     const existing = obj.fields.get(head);
     const newVal = await this.astToResolverValueAsync(field.value, childPrefix);
     if (existing !== void 0) {
-      obj.priorValues.set(head, existing);
+      const exFolded = foldNestedSelfRefs(existing, childPrefix);
+      const oldPrior = obj.priorValues.get(head);
+      const prior = foldOrSkipPrior(exFolded, fullKey, oldPrior);
+      if (prior !== void 0) obj.priorValues.set(head, prior);
     }
     if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
-      deepMergeResObjInto(existing, newVal);
+      deepMergeResObjInto(existing, newVal, childPrefix);
       return;
     }
     obj.fields.set(head, newVal);
@@ -1792,6 +2031,23 @@ var SubstitutionResolver = class {
     // narrower than path-equality. Spec amendment deferred to a follow-up
     // xx.hocon PR (see Phase 6 #3f close-out notes).
     this.resolvingConcats = /* @__PURE__ */ new WeakSet();
+    // Path stack tracking the full dotted path of the field currently being
+    // assigned in `resolveResObj`. Leaf keys are pushed on entry to each
+    // `(key, val)` iteration and popped on exit, so nested objects build up
+    // the full path (e.g. `["o", "history"]` while resolving `o.history`).
+    //
+    // Used to tighten self-ref detection at the L192 found-lookup site:
+    // a substitution `${X}` whose looked-up value contains a Subst pointing
+    // at `X` is only a true self-reference when the field currently being
+    // assigned is `X` (or a descendant of `X`). Without this guard, an
+    // external lookup like `b = ${o}` (where o has a self-referential
+    // field) would mis-fire and short-circuit to o's prior, returning the
+    // wrong value for b. The is_owner gate (rfp prefix-matches s.segments)
+    // narrows the check to the owner case only.
+    //
+    // Cross-impl with rs.hocon v1.5.1's resolving_field_path (same purpose,
+    // same prefix-match semantics).
+    this.resolvingFieldPath = [];
   }
   /** Returns a prefix for error messages, including origin info when set. */
   originPrefix() {
@@ -1803,7 +2059,13 @@ var SubstitutionResolver = class {
   resolveResObj(obj) {
     const result = /* @__PURE__ */ new Map();
     for (const [key, val] of obj.fields) {
-      const resolved = this.resolveVal(val, obj);
+      this.resolvingFieldPath.push(key);
+      let resolved;
+      try {
+        resolved = this.resolveVal(val, obj);
+      } finally {
+        this.resolvingFieldPath.pop();
+      }
       if (resolved !== void 0) {
         if (resolved.kind === "object") {
           const prior = obj.priorValues.get(key);
@@ -1893,7 +2155,10 @@ var SubstitutionResolver = class {
     try {
       const found = lookupPath(this.root, s.segments);
       if (found !== void 0) {
-        if (isConcat(found) && this.resolvingConcats.has(found)) {
+        const rfp = this.resolvingFieldPath;
+        const isOwner = rfp.length >= s.segments.length && s.segments.every((seg, i) => rfp[i] === seg.text);
+        const isSelfRef = isConcat(found) && this.resolvingConcats.has(found) || isOwner && containsSubstByPath(found, s.segments);
+        if (isSelfRef) {
           let prior;
           if (s.segments.length > 1) {
             const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
@@ -2104,8 +2369,33 @@ var SubstitutionResolver = class {
   }
   resolveAppend(a, scope) {
     const existing = this.resolveVal(a.existing, scope) ?? { kind: "array", items: [] };
+    if (this.opts.allowUnresolved && (isSubst(existing) || isConcat(existing) || isAppend(existing))) {
+      return a;
+    }
     const elem = this.resolveVal(a.elem, scope);
-    const items = existing.kind === "array" ? [...existing.items] : [existing];
+    let priorItems;
+    if (existing.kind === "array") {
+      priorItems = existing.items;
+    } else if (existing.kind === "object") {
+      const converted = numericObjectToArray(existing);
+      if (converted === null) {
+        throw new ResolveError(
+          `'+=' on non-array value: prior value is object with non-numeric keys (spec L732)`,
+          "",
+          0,
+          0
+        );
+      }
+      priorItems = converted;
+    } else {
+      throw new ResolveError(
+        `'+=' on non-array value: prior value is ${existing.kind} (spec L732)`,
+        "",
+        0,
+        0
+      );
+    }
+    const items = [...priorItems];
     if (elem !== void 0) items.push(elem);
     return { kind: "array", items };
   }
@@ -2207,6 +2497,9 @@ var Config = class _Config {
   }
   getString(path2) {
     const v = this.requireScalar(path2);
+    if (v.valueType === "null") {
+      throw new ConfigError(`expected string at ${path2}, got ${v.valueType}`, path2);
+    }
     return v.raw;
   }
   getNumber(path2) {