Function commitContainer

packages/core/src/runtime/commit/container.ts:87–409

(
  instanceId: InstanceId,
  vnode: VNode,
  prev: RuntimeInstance | null,
  ctx: CommitCtx,
  nodePath: string[],
  depth: number,
  commitNode: CommitNodeFn,
)

}

export function commitContainer(
  instanceId: InstanceId,
  vnode: VNode,
  prev: RuntimeInstance | null,
  ctx: CommitCtx,
  nodePath: string[],
  depth: number,
  commitNode: CommitNodeFn,
): CommitNodeResult {
  void depth;
  const parentProps = vnode.props as { id?: unknown } | undefined;
  const parentId =
    typeof parentProps?.id === "string" && parentProps.id.length > 0 ? parentProps.id : undefined;

  const prevChildren = prev ? prev.children : [];
  const compositeWrapperChildren = ctx.containerChildOverrides.get(instanceId) ?? null;
  const res = reconcileChildren(
    instanceId,
    prevChildren,
    compositeWrapperChildren ? compositeWrapperChildren : commitChildrenForVNode(vnode),
    ctx.allocator,
    {
      kind: vnode.kind,
      ...(parentId === undefined ? {} : { id: parentId }),
    },
  );
  if (!res.ok) return { ok: false, fatal: res.fatal };

  const byPrevIndex = prevChildren;
  let byPrevInstanceId: Map<InstanceId, RuntimeInstance> | null = null;
  if (res.value.unmountedInstanceIds.length > 0) {
    byPrevInstanceId = new Map<InstanceId, RuntimeInstance>();
    for (const c of prevChildren) byPrevInstanceId.set(c.instanceId, c);
  }

  const parentCompositeTheme = currentCompositeTheme(ctx);
  let pushedCompositeTheme = false;
  if (parentCompositeTheme !== null) {
    const nextCompositeTheme = resolveCompositeChildTheme(parentCompositeTheme, vnode);
    if (nextCompositeTheme !== parentCompositeTheme) {
      ctx.compositeThemeStack.push(nextCompositeTheme);
      pushedCompositeTheme = true;
    }
  }

  try {
    const canTryFastReuse =
      prev !== null &&
      res.value.newInstanceIds.length === 0 &&
      res.value.unmountedInstanceIds.length === 0 &&
      res.value.nextChildren.length === prevChildren.length;
    let childOrderStable = true;
    if (canTryFastReuse) {
      for (let i = 0; i < res.value.nextChildren.length; i++) {
        const child = res.value.nextChildren[i];
        if (!child || child.prevIndex !== i) {
          childOrderStable = false;
          break;