@jay-framework/runtime 0.15.5 → 0.15.6

package/dist/index.d.ts

@@ -576,13 +576,26 @@ declare class ConstructContext<ViewState> {
     /** The accumulated trackBy values from ancestor forEach loops (for __headlessInstances key lookup) */
     get dataIds(): Coordinate;
     coordinate: (refName: string) => Coordinate;
+    /**
+     * Create a child context for a forEach/slowForEach item.
+     *
+     * With scoped coordinates (DL#126), coordinateBase is NOT accumulated —
+     * scoped coordinates are fully qualified within each scope. Only dataIds
+     * accumulates (for __headlessInstances key lookup).
+     *
+     * coordinateBase is still maintained for the non-hydration path where
+     * coordinate() is used for refs.
+     */
     forItem<ChildViewState>(childViewState: ChildViewState, id: string): ConstructContext<ChildViewState>;
     /**
-     * Create a child context scoped to a headless instance's coordinate prefix.
-     * Extends coordinateBase for coordinate resolution but does NOT add to dataIds
-     * (instance segments are not trackBy values).
+     * Create a child context scoped to a DOM subtree (DL#126).
+     *
+     * Builds a LOCAL coordinate map from the scope root element's subtree.
+     * All coordinate lookups within this scope search the local map only.
+     * This ensures forEach items with shared scope IDs resolve correctly —
+     * each item builds its own local map from its own DOM branch.
      */
-    forInstance(instanceCoordinate: string): ConstructContext<ViewState>;
+    forScope(scopeRootElement: Element): ConstructContext<ViewState>;
     forAsync<ChildViewState>(childViewState: ChildViewState): ConstructContext<ChildViewState>;
     /** Whether this context is in hydration mode (adopting existing DOM). */
     get isHydrating(): boolean;
@@ -590,11 +603,14 @@ declare class ConstructContext<ViewState> {
     get rootElement(): Element | undefined;
     /**
      * Resolve an element by its coordinate key from the hydration map.
-     * The key is scoped by the current coordinateBase — e.g., inside a forEach
-     * item with trackBy "item-1", resolveCoordinate("addBtn") looks up "item-1/addBtn".
      *
-     * When multiple elements share the same coordinate (e.g., duplicate ref names),
-     * each call returns the next element in document order.
+     * With scoped coordinates (DL#126), the key is fully qualified within the
+     * scope (e.g., "S2/0"). No coordinateBase prefix is applied — coordinates
+     * are self-contained within their scope.
+     *
+     * When multiple elements share the same coordinate (e.g., forEach items
+     * sharing the same template scope IDs), each call returns the next element
+     * in document order.
      */
     resolveCoordinate(key: string): Element | undefined;
     /**
@@ -696,28 +712,25 @@ declare function hydrateConditional<ViewState>(condition: (vs: ViewState) => boo
  *
  * @param accessor - Function to get the array from the ViewState
  * @param trackBy - Property name used for item identity (reconciliation key)
+ * @param itemCoordinate - Scoped coordinate of each forEach item root element (DL#126).
+ *   All items share this coordinate; each resolveCoordinate call consumes the next one.
  * @param adoptItem - Called per existing item during hydration (should use adoptText/adoptElement)
  * @param createItem - Called per new item (regular element()/dynamicText() from generated-element.ts)
  */
-declare function hydrateForEach<ViewState, Item>(accessor: (vs: ViewState) => Item[], trackBy: string, adoptItem: () => BaseJayElement<Item>[], createItem: (item: Item, id: string) => BaseJayElement<Item>): DynamicChild<ViewState>;
+declare function hydrateForEach<ViewState, Item>(accessor: (vs: ViewState) => Item[], trackBy: string, itemCoordinate: string, adoptItem: () => BaseJayElement<Item>[], createItem: (item: Item, id: string) => BaseJayElement<Item>): DynamicChild<ViewState>;
 /**
  * Hydration-aware child component instantiation.
  *
- * Like childComp, but extends the current ConstructContext's coordinateBase
- * with the instance's coordinate key before calling the component factory.
- * This scopes coordinate resolution so that adoptElement('0') inside the
- * child's inline template resolves to '{instanceCoordinate}/0' in the
- * page's coordinate map.
- *
- * Used for headless component instances during hydration. The child
- * component's preRender calls ConstructContext.withHydrationChildContext()
- * which inherits the scoped coordinateBase.
+ * With scoped coordinates (DL#126), the child component creates a LOCAL
+ * coordinate map from its inline template root element's subtree.
+ * This ensures the child's adopt calls resolve against the correct DOM
+ * branch, not the global map.
  *
  * @param compCreator - Component factory (from makeHeadlessInstanceComponent)
  * @param getProps - Extracts component props from parent ViewState
- * @param instanceCoordinate - The instance's coordinate key (e.g., 'product-card:0')
+ * @param scopeRootCoordinate - Coordinate of the inline template root element (e.g., "S2/0")
  * @param ref - Optional ref for the component instance
  */
-declare function childCompHydrate<ParentVS, Props, ChildT, ChildElement extends BaseJayElement<ChildT>, ChildComp extends JayComponent<Props, ChildT, ChildElement>>(compCreator: JayComponentConstructor<Props>, getProps: (t: ParentVS) => Props, instanceCoordinate: string, ref?: PrivateRef<ParentVS, ChildComp>): BaseJayElement<ParentVS>;
+declare function childCompHydrate<ParentVS, Props, ChildT, ChildElement extends BaseJayElement<ChildT>, ChildComp extends JayComponent<Props, ChildT, ChildElement>>(compCreator: JayComponentConstructor<Props>, getProps: (t: ParentVS) => Props, scopeRootCoordinate?: string, ref?: PrivateRef<ParentVS, ChildComp>): BaseJayElement<ParentVS>;
 
 export { type Attribute, type Attributes, type BaseJayElement, BaseReferencesManager, type ComponentCollectionProxy, ComponentCollectionRefImpl, type ComponentProxy, ComponentRefImpl, ComponentRefsImpl, type Conditional, ConstructContext, type ContextMarker, type Coordinate, type DynamicAttributeOrProperty, EVENT_TRAP, type ElementFrom, type EventEmitter, type EventTypeFrom, type ExtractFastViewState, type ExtractInteractiveViewState, type ExtractProps, type ExtractRefs, type ExtractSlowViewState, type ExtractViewState, type ForEach, GetTrapProxy, type GlobalJayEvents, type HTMLElementCollectionProxy, type HTMLElementCollectionProxyTarget, type HTMLElementProxy, type HTMLElementProxyTarget, type HTMLNativeExec, type HeadLink, type JayComponent, type JayComponentConstructor, type JayContract, type JayElement, type JayEvent, type JayEventHandler, type JayEventHandlerWrapper, type JayLog, type JayNativeEventBuilder, type JayNativeFunction, LogType, type ManagedRefConstructor, ManagedRefType, type ManagedRefs, type MapEventEmitterViewState, type MountFunc, type OnlyEventEmitters, type PreRenderElement, type PrivateRef, type PrivateRefConstructor, PrivateRefs, type PropsFrom, ReferencesManager, type RenderElement, type RenderElementOptions, STATIC, type TextElement, VIEW_STATE_CHANGE_EVENT, type ViewStateFrom, type When, WhenRole, type WithData, adoptDynamicElement, adoptElement, adoptText, booleanAttribute, childComp, childCompHydrate, clearGlobalContextRegistry, conditional, createJayContext, currentConstructionContext, defaultEventWrapper, dynamicAttribute, dynamicElement, dynamicElementNS, dynamicProperty, dynamicText, element, findContext, forEach, hydrateConditional, hydrateForEach, injectHeadLinks, isCondition, isForEach, isWhen, isWithData, jayLog, mathMLDynamicElement, mathMLElement, mkUpdateCollection, noop, noopMount, noopUpdate, normalizeMount, normalizeUpdates, pending, registerGlobalContext, rejected, resolved, restoreContext, saveContext, slowForEachItem, svgDynamicElement, svgElement, type updateFunc, useContext, useGlobalContext, withContext, withData };

package/dist/index.js

@@ -196,6 +196,16 @@ class ConstructContext {
   get dataIds() {
     return this._dataIds;
   }
+  /**
+   * Create a child context for a forEach/slowForEach item.
+   *
+   * With scoped coordinates (DL#126), coordinateBase is NOT accumulated —
+   * scoped coordinates are fully qualified within each scope. Only dataIds
+   * accumulates (for __headlessInstances key lookup).
+   *
+   * coordinateBase is still maintained for the non-hydration path where
+   * coordinate() is used for refs.
+   */
   forItem(childViewState, id) {
     return new ConstructContext(
       childViewState,
@@ -207,18 +217,21 @@ class ConstructContext {
     );
   }
   /**
-   * Create a child context scoped to a headless instance's coordinate prefix.
-   * Extends coordinateBase for coordinate resolution but does NOT add to dataIds
-   * (instance segments are not trackBy values).
+   * Create a child context scoped to a DOM subtree (DL#126).
+   *
+   * Builds a LOCAL coordinate map from the scope root element's subtree.
+   * All coordinate lookups within this scope search the local map only.
+   * This ensures forEach items with shared scope IDs resolve correctly —
+   * each item builds its own local map from its own DOM branch.
    */
-  forInstance(instanceCoordinate) {
-    const segments = instanceCoordinate.split("/");
+  forScope(scopeRootElement) {
+    const localMap = buildCoordinateMap(scopeRootElement);
     return new ConstructContext(
       this.data,
       false,
-      [...this.coordinateBase, ...segments],
-      this._coordinateMap,
-      this._rootElement,
+      this.coordinateBase,
+      localMap,
+      scopeRootElement,
       this._dataIds
     );
   }
@@ -242,18 +255,19 @@ class ConstructContext {
   }
   /**
    * Resolve an element by its coordinate key from the hydration map.
-   * The key is scoped by the current coordinateBase — e.g., inside a forEach
-   * item with trackBy "item-1", resolveCoordinate("addBtn") looks up "item-1/addBtn".
    *
-   * When multiple elements share the same coordinate (e.g., duplicate ref names),
-   * each call returns the next element in document order.
+   * With scoped coordinates (DL#126), the key is fully qualified within the
+   * scope (e.g., "S2/0"). No coordinateBase prefix is applied — coordinates
+   * are self-contained within their scope.
+   *
+   * When multiple elements share the same coordinate (e.g., forEach items
+   * sharing the same template scope IDs), each call returns the next element
+   * in document order.
    */
   resolveCoordinate(key) {
     if (!this._coordinateMap)
       return void 0;
-    const base = this.coordinateBase.length > 0 ? this.coordinateBase.join("/") : "";
-    const fullKey = base ? key ? base + "/" + key : base : key;
-    const elements = this._coordinateMap.get(fullKey);
+    const elements = this._coordinateMap.get(key);
     if (!elements || elements.length === 0)
       return void 0;
     return elements.shift();
@@ -267,9 +281,7 @@ class ConstructContext {
   peekCoordinate(key) {
     if (!this._coordinateMap)
       return void 0;
-    const base = this.coordinateBase.length > 0 ? this.coordinateBase.join("/") : "";
-    const fullKey = base ? key ? base + "/" + key : base : key;
-    const elements = this._coordinateMap.get(fullKey);
+    const elements = this._coordinateMap.get(key);
     if (!elements || elements.length === 0)
       return void 0;
     return elements[0];
@@ -1256,11 +1268,19 @@ function adoptBase(coordinate, attributes, ref) {
     if (typeof value === "object" && value !== null && "valueFunc" in value) {
       const dynAttr = value;
       let attrValue = dynAttr.valueFunc(context.currData);
+      const isBooleanAttr = dynAttr.style === 3;
       if (!(key === STYLE && element2 instanceof HTMLElement)) {
         updates.push((newData) => {
           const newAttrValue = dynAttr.valueFunc(newData);
           if (newAttrValue !== attrValue) {
-            element2.setAttribute(key, newAttrValue);
+            if (isBooleanAttr) {
+              if (newAttrValue)
+                element2.setAttribute(key, "");
+              else
+                element2.removeAttribute(key);
+            } else {
+              element2.setAttribute(key, newAttrValue);
+            }
           }
           attrValue = newAttrValue;
         });
@@ -1418,17 +1438,18 @@ function hydrateConditional(condition, adoptExisting, createFallback) {
   };
   return result;
 }
-function hydrateForEach(accessor, trackBy, adoptItem, createItem) {
+function hydrateForEach(accessor, trackBy, itemCoordinate, adoptItem, createItem) {
   const context = currentConstructionContext();
   const savedContext = saveContext();
   const parentContext = context;
   const initialItems = accessor(context.currData) || [];
   const adoptedItems = [];
-  for (const item of initialItems) {
+  for (let i = 0; i < initialItems.length; i++) {
+    const item = initialItems[i];
     const id = String(item[trackBy]);
-    const itemDom = context.peekCoordinate(id);
-    const childContext = context.forItem(item, id);
-    const adopted = withContext(CONSTRUCTION_CONTEXT_MARKER, childContext, () => {
+    const itemDom = context.resolveCoordinate(itemCoordinate);
+    const scopedContext = itemDom ? context.forScope(itemDom).forItem(item, id) : context.forItem(item, id);
+    const adopted = withContext(CONSTRUCTION_CONTEXT_MARKER, scopedContext, () => {
       const elements = adoptItem();
       const updates = [];
       const mounts = [];
@@ -1519,9 +1540,10 @@ function hydrateForEach(accessor, trackBy, adoptItem, createItem) {
   };
   return result;
 }
-function childCompHydrate(compCreator, getProps, instanceCoordinate, ref) {
+function childCompHydrate(compCreator, getProps, scopeRootCoordinate, ref) {
   const context = currentConstructionContext();
-  const childContext = context.forInstance(instanceCoordinate);
+  const scopeRoot = scopeRootCoordinate ? context.resolveCoordinate(scopeRootCoordinate) : void 0;
+  const childContext = scopeRoot ? context.forScope(scopeRoot) : context;
   return withContext(CONSTRUCTION_CONTEXT_MARKER, childContext, () => {
     const childComp2 = compCreator(getProps(context.currData));
     const updates = [(t) => childComp2.update(getProps(t))];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/runtime",
-  "version": "0.15.5",
+  "version": "0.15.6",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -23,11 +23,11 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/list-compare": "^0.15.5",
-    "@jay-framework/reactive": "^0.15.5"
+    "@jay-framework/list-compare": "^0.15.6",
+    "@jay-framework/reactive": "^0.15.6"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.15.5",
+    "@jay-framework/dev-environment": "^0.15.6",
     "@testing-library/jest-dom": "^6.2.0",
     "@types/jsdom": "^21.1.6",
     "@types/node": "^20.11.5",