piral-blazor 1.0.0-pre.2217 → 1.0.0

package/src/internal/Rendering/LogicalElements.ts

@@ -1,289 +0,0 @@
-/*
-  A LogicalElement plays the same role as an Element instance from the point of view of the
-  API consumer. Inserting and removing logical elements updates the browser DOM just the same.
-
-  The difference is that, unlike regular DOM mutation APIs, the LogicalElement APIs don't use
-  the underlying DOM structure as the data storage for the element hierarchy. Instead, the
-  LogicalElement APIs take care of tracking hierarchical relationships separately. The point
-  of this is to permit a logical tree structure in which parent/child relationships don't
-  have to be materialized in terms of DOM element parent/child relationships. And the reason
-  why we want that is so that hierarchies of Blazor components can be tracked even when those
-  components' render output need not be a single literal DOM element.
-
-  Consumers of the API don't need to know about the implementation, but how it's done is:
-  - Each LogicalElement is materialized in the DOM as either:
-    - A Node instance, for actual Node instances inserted using 'insertLogicalChild' or
-      for Element instances promoted to LogicalElement via 'toLogicalElement'
-    - A Comment instance, for 'logical container' instances inserted using 'createAndInsertLogicalContainer'
-  - Then, on that instance (i.e., the Node or Comment), we store an array of 'logical children'
-    instances, e.g.,
-      [firstChild, secondChild, thirdChild, ...]
-    ... plus we store a reference to the 'logical parent' (if any)
-  - The 'logical children' array means we can look up in O(1):
-    - The number of logical children (not currently implemented because not required, but trivial)
-    - The logical child at any given index
-  - Whenever a logical child is added or removed, we update the parent's array of logical children
-*/
-
-const logicalChildrenPropname = createSymbolOrFallback('_blazorLogicalChildren');
-const logicalParentPropname = createSymbolOrFallback('_blazorLogicalParent');
-const logicalEndSiblingPropname = createSymbolOrFallback('_blazorLogicalEnd');
-
-export function toLogicalRootCommentElement(start: Comment, end: Comment): LogicalElement {
-  // Now that we support start/end comments as component delimiters we are going to be setting up
-  // adding the components rendered output as siblings of the start/end tags (between).
-  // For that to work, we need to appropriately configure the parent element to be a logical element
-  // with all their children being the child elements.
-  // For example, imagine you have
-  // <app>
-  // <div><p>Static content</p></div>
-  // <!-- start component
-  // <!-- end component
-  // <footer>Some other content</footer>
-  // <app>
-  // We want the parent element to be something like
-  // *app
-  // |- *div
-  // |- *component
-  // |- *footer
-  if (!start.parentNode) {
-    throw new Error(`Comment not connected to the DOM ${start.textContent}`);
-  }
-
-  const parent = start.parentNode;
-  const parentLogicalElement = toLogicalElement(parent, /* allow existing contents */ true);
-  const children = getLogicalChildrenArray(parentLogicalElement);
-  Array.from(parent.childNodes).forEach((n) => children.push((n as unknown) as LogicalElement));
-  start[logicalParentPropname] = parentLogicalElement;
-  // We might not have an end comment in the case of non-prerendered components.
-  if (end) {
-    start[logicalEndSiblingPropname] = end;
-    toLogicalElement(end, /* allowExistingcontents */ true);
-  }
-  return toLogicalElement(start, /* allowExistingContents */ true);
-}
-
-export function toLogicalElement(element: Node, allowExistingContents?: boolean): LogicalElement {
-  // Normally it's good to assert that the element has started empty, because that's the usual
-  // situation and we probably have a bug if it's not. But for the element that contain prerendered
-  // root components, we want to let them keep their content until we replace it.
-  if (element.childNodes.length > 0 && !allowExistingContents) {
-    throw new Error('New logical elements must start empty, or allowExistingContents must be true');
-  }
-
-  element[logicalChildrenPropname] = [];
-  return (element as unknown) as LogicalElement;
-}
-
-export function createAndInsertLogicalContainer(parent: LogicalElement, childIndex: number): LogicalElement {
-  const containerElement = document.createComment('!');
-  insertLogicalChild(containerElement, parent, childIndex);
-  return (containerElement as any) as LogicalElement;
-}
-
-export function insertLogicalChild(child: Node, parent: LogicalElement, childIndex: number) {
-  const childAsLogicalElement = (child as any) as LogicalElement;
-  if (child instanceof Comment) {
-    const existingGrandchildren = getLogicalChildrenArray(childAsLogicalElement);
-    if (existingGrandchildren && getLogicalChildrenArray(childAsLogicalElement).length > 0) {
-      // There's nothing to stop us implementing support for this scenario, and it's not difficult
-      // (after inserting 'child' itself, also iterate through its logical children and physically
-      // put them as following-siblings in the DOM). However there's no scenario that requires it
-      // presently, so if we did implement it there'd be no good way to have tests for it.
-      throw new Error('Not implemented: inserting non-empty logical container');
-    }
-  }
-
-  if (getLogicalParent(childAsLogicalElement)) {
-    // Likewise, we could easily support this scenario too (in this 'if' block, just splice
-    // out 'child' from the logical children array of its previous logical parent by using
-    // Array.prototype.indexOf to determine its previous sibling index).
-    // But again, since there's not currently any scenario that would use it, we would not
-    // have any test coverage for such an implementation.
-    throw new Error('Not implemented: moving existing logical children');
-  }
-
-  const newSiblings = getLogicalChildrenArray(parent);
-  if (childIndex < newSiblings.length) {
-    // Insert
-    const nextSibling = (newSiblings[childIndex] as any) as Node;
-    nextSibling.parentNode!.insertBefore(child, nextSibling);
-    newSiblings.splice(childIndex, 0, childAsLogicalElement);
-  } else {
-    // Append
-    appendDomNode(child, parent);
-    newSiblings.push(childAsLogicalElement);
-  }
-
-  childAsLogicalElement[logicalParentPropname] = parent;
-  if (!(logicalChildrenPropname in childAsLogicalElement)) {
-    childAsLogicalElement[logicalChildrenPropname] = [];
-  }
-}
-
-export function removeLogicalChild(parent: LogicalElement, childIndex: number) {
-  const childrenArray = getLogicalChildrenArray(parent);
-  const childToRemove = childrenArray.splice(childIndex, 1)[0];
-
-  // If it's a logical container, also remove its descendants
-  if (childToRemove instanceof Comment) {
-    const grandchildrenArray = getLogicalChildrenArray(childToRemove);
-    while (grandchildrenArray.length > 0) {
-      removeLogicalChild(childToRemove, 0);
-    }
-  }
-
-  // Finally, remove the node itself
-  const domNodeToRemove = (childToRemove as any) as Node;
-  domNodeToRemove.parentNode!.removeChild(domNodeToRemove);
-}
-
-export function getLogicalParent(element: LogicalElement): LogicalElement | null {
-  return (element[logicalParentPropname] as LogicalElement) || null;
-}
-
-export function getLogicalSiblingEnd(element: LogicalElement): LogicalElement | null {
-  return (element[logicalEndSiblingPropname] as LogicalElement) || null;
-}
-
-export function getLogicalChild(parent: LogicalElement, childIndex: number): LogicalElement {
-  return getLogicalChildrenArray(parent)[childIndex];
-}
-
-export function isSvgElement(element: LogicalElement) {
-  return getClosestDomElement(element).namespaceURI === 'http://www.w3.org/2000/svg';
-}
-
-export function getLogicalChildrenArray(element: LogicalElement) {
-  return element[logicalChildrenPropname] as LogicalElement[];
-}
-
-export function permuteLogicalChildren(parent: LogicalElement, permutationList: PermutationListEntry[]) {
-  // The permutationList must represent a valid permutation, i.e., the list of 'from' indices
-  // is distinct, and the list of 'to' indices is a permutation of it. The algorithm here
-  // relies on that assumption.
-
-  // Each of the phases here has to happen separately, because each one is designed not to
-  // interfere with the indices or DOM entries used by subsequent phases.
-
-  // Phase 1: track which nodes we will move
-  const siblings = getLogicalChildrenArray(parent);
-  permutationList.forEach((listEntry: PermutationListEntryWithTrackingData) => {
-    listEntry.moveRangeStart = siblings[listEntry.fromSiblingIndex];
-    listEntry.moveRangeEnd = findLastDomNodeInRange(listEntry.moveRangeStart);
-  });
-
-  // Phase 2: insert markers
-  permutationList.forEach((listEntry: PermutationListEntryWithTrackingData) => {
-    const marker = (listEntry.moveToBeforeMarker = document.createComment('marker'));
-    const insertBeforeNode = (siblings[listEntry.toSiblingIndex + 1] as any) as Node;
-    if (insertBeforeNode) {
-      insertBeforeNode.parentNode!.insertBefore(marker, insertBeforeNode);
-    } else {
-      appendDomNode(marker, parent);
-    }
-  });
-
-  // Phase 3: move descendants & remove markers
-  permutationList.forEach((listEntry: PermutationListEntryWithTrackingData) => {
-    const insertBefore = listEntry.moveToBeforeMarker!;
-    const parentDomNode = insertBefore.parentNode!;
-    const elementToMove = listEntry.moveRangeStart!;
-    const moveEndNode = listEntry.moveRangeEnd!;
-    let nextToMove = (elementToMove as any) as Node | null;
-    while (nextToMove) {
-      const nextNext = nextToMove.nextSibling;
-      parentDomNode.insertBefore(nextToMove, insertBefore);
-
-      if (nextToMove === moveEndNode) {
-        break;
-      } else {
-        nextToMove = nextNext;
-      }
-    }
-
-    parentDomNode.removeChild(insertBefore);
-  });
-
-  // Phase 4: update siblings index
-  permutationList.forEach((listEntry: PermutationListEntryWithTrackingData) => {
-    siblings[listEntry.toSiblingIndex] = listEntry.moveRangeStart!;
-  });
-}
-
-export function getClosestDomElement(logicalElement: LogicalElement) {
-  if (logicalElement instanceof Element) {
-    return logicalElement;
-  } else if (logicalElement instanceof Comment) {
-    return logicalElement.parentNode! as Element;
-  } else {
-    throw new Error('Not a valid logical element');
-  }
-}
-
-export interface PermutationListEntry {
-  fromSiblingIndex: number;
-  toSiblingIndex: number;
-}
-
-interface PermutationListEntryWithTrackingData extends PermutationListEntry {
-  // These extra properties are used internally when processing the permutation list
-  moveRangeStart?: LogicalElement;
-  moveRangeEnd?: Node;
-  moveToBeforeMarker?: Node;
-}
-
-function getLogicalNextSibling(element: LogicalElement): LogicalElement | null {
-  const siblings = getLogicalChildrenArray(getLogicalParent(element)!);
-  const siblingIndex = Array.prototype.indexOf.call(siblings, element);
-  return siblings[siblingIndex + 1] || null;
-}
-
-function appendDomNode(child: Node, parent: LogicalElement) {
-  // This function only puts 'child' into the DOM in the right place relative to 'parent'
-  // It does not update the logical children array of anything
-  if (parent instanceof Element) {
-    parent.appendChild(child);
-  } else if (parent instanceof Comment) {
-    const parentLogicalNextSibling = (getLogicalNextSibling(parent) as any) as Node;
-    if (parentLogicalNextSibling) {
-      // Since the parent has a logical next-sibling, its appended child goes right before that
-      parentLogicalNextSibling.parentNode!.insertBefore(child, parentLogicalNextSibling);
-    } else {
-      // Since the parent has no logical next-sibling, keep recursing upwards until we find
-      // a logical ancestor that does have a next-sibling or is a physical element.
-      appendDomNode(child, getLogicalParent(parent)!);
-    }
-  } else {
-    // Should never happen
-    throw new Error(`Cannot append node because the parent is not a valid logical element. Parent: ${parent}`);
-  }
-}
-
-// Returns the final node (in depth-first evaluation order) that is a descendant of the logical element.
-// As such, the entire subtree is between 'element' and 'findLastDomNodeInRange(element)' inclusive.
-function findLastDomNodeInRange(element: LogicalElement) {
-  if (element instanceof Element) {
-    return element;
-  }
-
-  const nextSibling = getLogicalNextSibling(element);
-  if (nextSibling) {
-    // Simple case: not the last logical sibling, so take the node before the next sibling
-    return ((nextSibling as any) as Node).previousSibling;
-  } else {
-    // Harder case: there's no logical next-sibling, so recurse upwards until we find
-    // a logical ancestor that does have one, or a physical element
-    const logicalParent = getLogicalParent(element)!;
-    return logicalParent instanceof Element ? logicalParent.lastChild : findLastDomNodeInRange(logicalParent);
-  }
-}
-
-function createSymbolOrFallback(fallback: string): symbol | string {
-  return typeof Symbol === 'function' ? Symbol() : fallback;
-}
-
-// Nominal type to represent a logical element without needing to allocate any object for instances
-export interface LogicalElement {
-  LogicalElement__DO_NOT_IMPLEMENT: any;
-}

package/src/internal/Rendering/RenderBatch/BinaryDecoder.ts

@@ -1,43 +0,0 @@
-const uint64HighPartShift = Math.pow(2, 32);
-const maxSafeNumberHighPart = Math.pow(2, 21) - 1; // The high-order int32 from Number.MAX_SAFE_INTEGER
-
-export function readInt32LE(buffer: Uint8Array, position: number): any {
-  return buffer[position] | (buffer[position + 1] << 8) | (buffer[position + 2] << 16) | (buffer[position + 3] << 24);
-}
-
-export function readUint32LE(buffer: Uint8Array, position: number): any {
-  return (
-    buffer[position] + (buffer[position + 1] << 8) + (buffer[position + 2] << 16) + ((buffer[position + 3] << 24) >>> 0)
-  ); // The >>> 0 coerces the value to unsigned
-}
-
-export function readUint64LE(buffer: Uint8Array, position: number): any {
-  // This cannot be done using bit-shift operators in JavaScript, because
-  // those all implicitly convert to int32
-  const highPart = readUint32LE(buffer, position + 4);
-  if (highPart > maxSafeNumberHighPart) {
-    throw new Error(
-      `Cannot read uint64 with high order part ${highPart}, because the result would exceed Number.MAX_SAFE_INTEGER.`,
-    );
-  }
-
-  return highPart * uint64HighPartShift + readUint32LE(buffer, position);
-}
-
-export function readLEB128(buffer: Uint8Array, position: number) {
-  let result = 0;
-  let shift = 0;
-  for (let index = 0; index < 4; index++) {
-    const byte = buffer[position + index];
-    result |= (byte & 127) << shift;
-    if (byte < 128) {
-      break;
-    }
-    shift += 7;
-  }
-  return result;
-}
-
-export function numLEB128Bytes(value: number) {
-  return value < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : 4;
-}

package/src/internal/Rendering/RenderBatch/OutOfProcessRenderBatch.ts

@@ -1,244 +0,0 @@
-import {
-  RenderBatch,
-  ArrayRange,
-  RenderTreeDiff,
-  ArrayValues,
-  RenderTreeEdit,
-  EditType,
-  FrameType,
-  RenderTreeFrame,
-  RenderTreeDiffReader,
-  RenderTreeFrameReader,
-  RenderTreeEditReader,
-  ArrayRangeReader,
-  ArrayBuilderSegmentReader,
-  ArrayBuilderSegment,
-} from './RenderBatch';
-import { decodeUtf8 } from './Utf8Decoder';
-import { readInt32LE, readUint64LE, readLEB128, numLEB128Bytes } from './BinaryDecoder';
-
-const updatedComponentsEntryLength = 4; // Each is a single int32 giving the location of the data
-const referenceFramesEntryLength = 20; // 1 int for frame type, then 16 bytes for type-specific data
-const disposedComponentIdsEntryLength = 4; // Each is an int32 giving the ID
-const disposedEventHandlerIdsEntryLength = 8; // Each is an int64 giving the ID
-const editsEntryLength = 16; // 4 ints
-const stringTableEntryLength = 4; // Each is an int32 giving the string data location, or -1 for null
-
-export class OutOfProcessRenderBatch implements RenderBatch {
-  constructor(private batchData: Uint8Array) {
-    const stringReader = new OutOfProcessStringReader(batchData);
-
-    this.arrayRangeReader = new OutOfProcessArrayRangeReader(batchData);
-    this.arrayBuilderSegmentReader = new OutOfProcessArrayBuilderSegmentReader(batchData);
-    this.diffReader = new OutOfProcessRenderTreeDiffReader(batchData);
-    this.editReader = new OutOfProcessRenderTreeEditReader(batchData, stringReader);
-    this.frameReader = new OutOfProcessRenderTreeFrameReader(batchData, stringReader);
-  }
-
-  updatedComponents(): ArrayRange<RenderTreeDiff> {
-    return readInt32LE(this.batchData, this.batchData.length - 20); // 5th-from-last int32
-  }
-
-  referenceFrames(): ArrayRange<RenderTreeFrame> {
-    return readInt32LE(this.batchData, this.batchData.length - 16); // 4th-from-last int32
-  }
-
-  disposedComponentIds(): ArrayRange<number> {
-    return readInt32LE(this.batchData, this.batchData.length - 12); // 3rd-from-last int32
-  }
-
-  disposedEventHandlerIds(): ArrayRange<number> {
-    return readInt32LE(this.batchData, this.batchData.length - 8); // 2th-from-last int32
-  }
-
-  updatedComponentsEntry(values: ArrayValues<RenderTreeDiff>, index: number): RenderTreeDiff {
-    const tableEntryPos = (values as any) + index * updatedComponentsEntryLength;
-    return readInt32LE(this.batchData, tableEntryPos);
-  }
-
-  referenceFramesEntry(values: ArrayValues<RenderTreeFrame>, index: number): RenderTreeFrame {
-    return ((values as any) + index * referenceFramesEntryLength) as any;
-  }
-
-  disposedComponentIdsEntry(values: ArrayValues<number>, index: number): number {
-    const entryPos = (values as any) + index * disposedComponentIdsEntryLength;
-    return readInt32LE(this.batchData, entryPos);
-  }
-
-  disposedEventHandlerIdsEntry(values: ArrayValues<number>, index: number): number {
-    const entryPos = (values as any) + index * disposedEventHandlerIdsEntryLength;
-    return readUint64LE(this.batchData, entryPos);
-  }
-
-  diffReader: RenderTreeDiffReader;
-
-  editReader: RenderTreeEditReader;
-
-  frameReader: RenderTreeFrameReader;
-
-  arrayRangeReader: ArrayRangeReader;
-
-  arrayBuilderSegmentReader: ArrayBuilderSegmentReader;
-}
-
-class OutOfProcessRenderTreeDiffReader implements RenderTreeDiffReader {
-  constructor(private batchDataUint8: Uint8Array) {}
-
-  componentId(diff: RenderTreeDiff) {
-    // First int32 is componentId
-    return readInt32LE(this.batchDataUint8, diff as any);
-  }
-
-  edits(diff: RenderTreeDiff) {
-    // Entries data starts after the componentId (which is a 4-byte int)
-    return (diff as any) + 4;
-  }
-
-  editsEntry(values: ArrayValues<RenderTreeEdit>, index: number) {
-    return (values as any) + index * editsEntryLength;
-  }
-}
-
-class OutOfProcessRenderTreeEditReader implements RenderTreeEditReader {
-  constructor(private batchDataUint8: Uint8Array, private stringReader: OutOfProcessStringReader) {}
-
-  editType(edit: RenderTreeEdit) {
-    return readInt32LE(this.batchDataUint8, edit as any); // 1st int
-  }
-
-  siblingIndex(edit: RenderTreeEdit) {
-    return readInt32LE(this.batchDataUint8, (edit as any) + 4); // 2nd int
-  }
-
-  newTreeIndex(edit: RenderTreeEdit) {
-    return readInt32LE(this.batchDataUint8, (edit as any) + 8); // 3rd int
-  }
-
-  moveToSiblingIndex(edit: RenderTreeEdit) {
-    return readInt32LE(this.batchDataUint8, (edit as any) + 8); // 3rd int
-  }
-
-  removedAttributeName(edit: RenderTreeEdit) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (edit as any) + 12); // 4th int
-    return this.stringReader.readString(stringIndex);
-  }
-}
-
-class OutOfProcessRenderTreeFrameReader implements RenderTreeFrameReader {
-  constructor(private batchDataUint8: Uint8Array, private stringReader: OutOfProcessStringReader) {}
-
-  // For render frames, the 2nd-4th ints have different meanings depending on frameType.
-  // It's the caller's responsibility not to evaluate properties that aren't applicable to the frameType.
-
-  frameType(frame: RenderTreeFrame) {
-    return readInt32LE(this.batchDataUint8, frame as any); // 1st int
-  }
-
-  subtreeLength(frame: RenderTreeFrame) {
-    return readInt32LE(this.batchDataUint8, (frame as any) + 4); // 2nd int
-  }
-
-  elementReferenceCaptureId(frame: RenderTreeFrame) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (frame as any) + 4); // 2nd int
-    return this.stringReader.readString(stringIndex);
-  }
-
-  componentId(frame: RenderTreeFrame) {
-    return readInt32LE(this.batchDataUint8, (frame as any) + 8); // 3rd int
-  }
-
-  elementName(frame: RenderTreeFrame) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (frame as any) + 8); // 3rd int
-    return this.stringReader.readString(stringIndex);
-  }
-
-  textContent(frame: RenderTreeFrame) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (frame as any) + 4); // 2nd int
-    return this.stringReader.readString(stringIndex);
-  }
-
-  markupContent(frame: RenderTreeFrame) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (frame as any) + 4); // 2nd int
-    return this.stringReader.readString(stringIndex)!;
-  }
-
-  attributeName(frame: RenderTreeFrame) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (frame as any) + 4); // 2nd int
-    return this.stringReader.readString(stringIndex);
-  }
-
-  attributeValue(frame: RenderTreeFrame) {
-    const stringIndex = readInt32LE(this.batchDataUint8, (frame as any) + 8); // 3rd int
-    return this.stringReader.readString(stringIndex);
-  }
-
-  attributeEventHandlerId(frame: RenderTreeFrame) {
-    return readUint64LE(this.batchDataUint8, (frame as any) + 12); // Bytes 12-19
-  }
-}
-
-class OutOfProcessStringReader {
-  private stringTableStartIndex: number;
-
-  constructor(private batchDataUint8: Uint8Array) {
-    // Final int gives start position of the string table
-    this.stringTableStartIndex = readInt32LE(batchDataUint8, batchDataUint8.length - 4);
-  }
-
-  readString(index: number): string | null {
-    if (index === -1) {
-      // Special value encodes 'null'
-      return null;
-    } else {
-      const stringTableEntryPos = readInt32LE(
-        this.batchDataUint8,
-        this.stringTableStartIndex + index * stringTableEntryLength,
-      );
-
-      // By default, .NET's BinaryWriter gives LEB128-length-prefixed UTF-8 data.
-      // This is convenient enough to decode in JavaScript.
-      const numUtf8Bytes = readLEB128(this.batchDataUint8, stringTableEntryPos);
-      const charsStart = stringTableEntryPos + numLEB128Bytes(numUtf8Bytes);
-      const utf8Data = new Uint8Array(
-        this.batchDataUint8.buffer,
-        this.batchDataUint8.byteOffset + charsStart,
-        numUtf8Bytes,
-      );
-      return decodeUtf8(utf8Data);
-    }
-  }
-}
-
-class OutOfProcessArrayRangeReader implements ArrayRangeReader {
-  constructor(private batchDataUint8: Uint8Array) {}
-
-  count<T>(arrayRange: ArrayRange<T>) {
-    // First int is count
-    return readInt32LE(this.batchDataUint8, arrayRange as any);
-  }
-
-  values<T>(arrayRange: ArrayRange<T>) {
-    // Entries data starts after the 'count' int (i.e., after 4 bytes)
-    return (arrayRange as any) + 4;
-  }
-}
-
-class OutOfProcessArrayBuilderSegmentReader implements ArrayBuilderSegmentReader {
-  constructor(private batchDataUint8: Uint8Array) {}
-
-  offset<T>(arrayBuilderSegment: ArrayBuilderSegment<T>) {
-    // Not used by the out-of-process representation of RenderBatch data.
-    // This only exists on the ArrayBuilderSegmentReader for the shared-memory representation.
-    return 0;
-  }
-
-  count<T>(arrayBuilderSegment: ArrayBuilderSegment<T>) {
-    // First int is count
-    return readInt32LE(this.batchDataUint8, arrayBuilderSegment as any);
-  }
-
-  values<T>(arrayBuilderSegment: ArrayBuilderSegment<T>): ArrayValues<T> {
-    // Entries data starts after the 'count' int (i.e., after 4 bytes)
-    return (arrayBuilderSegment as any) + 4;
-  }
-}

package/src/internal/Rendering/RenderBatch/RenderBatch.ts

@@ -1,100 +0,0 @@
-export interface RenderBatch {
-  updatedComponents(): ArrayRange<RenderTreeDiff>;
-  referenceFrames(): ArrayRange<RenderTreeFrame>;
-  disposedComponentIds(): ArrayRange<number>;
-  disposedEventHandlerIds(): ArrayRange<number>;
-
-  updatedComponentsEntry(values: ArrayValues<RenderTreeDiff>, index: number): RenderTreeDiff;
-  referenceFramesEntry(values: ArrayValues<RenderTreeFrame>, index: number): RenderTreeFrame;
-  disposedComponentIdsEntry(values: ArrayValues<number>, index: number): number;
-  disposedEventHandlerIdsEntry(values: ArrayValues<number>, index: number): number;
-
-  diffReader: RenderTreeDiffReader;
-  editReader: RenderTreeEditReader;
-  frameReader: RenderTreeFrameReader;
-  arrayRangeReader: ArrayRangeReader;
-  arrayBuilderSegmentReader: ArrayBuilderSegmentReader;
-}
-
-export interface ArrayRangeReader {
-  count<T>(arrayRange: ArrayRange<T>): number;
-  values<T>(arrayRange: ArrayRange<T>): ArrayValues<T>;
-}
-
-export interface ArrayBuilderSegmentReader {
-  offset<T>(arrayBuilderSegment: ArrayBuilderSegment<T>): number;
-  count<T>(arrayBuilderSegment: ArrayBuilderSegment<T>): number;
-  values<T>(arrayBuilderSegment: ArrayBuilderSegment<T>): ArrayValues<T>;
-}
-
-export interface RenderTreeDiffReader {
-  componentId(diff: RenderTreeDiff): number;
-  edits(diff: RenderTreeDiff): ArrayBuilderSegment<RenderTreeEdit>;
-  editsEntry(values: ArrayValues<RenderTreeEdit>, index: number): RenderTreeEdit;
-}
-
-export interface RenderTreeEditReader {
-  editType(edit: RenderTreeEdit): EditType;
-  siblingIndex(edit: RenderTreeEdit): number;
-  newTreeIndex(edit: RenderTreeEdit): number;
-  moveToSiblingIndex(edit: RenderTreeEdit): number;
-  removedAttributeName(edit: RenderTreeEdit): string | null;
-}
-
-export interface RenderTreeFrameReader {
-  frameType(frame: RenderTreeFrame): FrameType;
-  subtreeLength(frame: RenderTreeFrame): number;
-  elementReferenceCaptureId(frame: RenderTreeFrame): string | null;
-  componentId(frame: RenderTreeFrame): number;
-  elementName(frame: RenderTreeFrame): string | null;
-  textContent(frame: RenderTreeFrame): string | null;
-  markupContent(frame: RenderTreeFrame): string;
-  attributeName(frame: RenderTreeFrame): string | null;
-  attributeValue(frame: RenderTreeFrame): string | null;
-  attributeEventHandlerId(frame: RenderTreeFrame): number;
-}
-
-export interface ArrayRange<T> {
-  ArrayRange__DO_NOT_IMPLEMENT: any;
-}
-export interface ArrayBuilderSegment<T> {
-  ArrayBuilderSegment__DO_NOT_IMPLEMENT: any;
-}
-export interface ArrayValues<T> {
-  ArrayValues__DO_NOT_IMPLEMENT: any;
-}
-
-export interface RenderTreeDiff {
-  RenderTreeDiff__DO_NOT_IMPLEMENT: any;
-}
-export interface RenderTreeFrame {
-  RenderTreeFrame__DO_NOT_IMPLEMENT: any;
-}
-export interface RenderTreeEdit {
-  RenderTreeEdit__DO_NOT_IMPLEMENT: any;
-}
-
-export enum EditType {
-  // The values must be kept in sync with the .NET equivalent in RenderTreeEditType.cs
-  prependFrame = 1,
-  removeFrame = 2,
-  setAttribute = 3,
-  removeAttribute = 4,
-  updateText = 5,
-  stepIn = 6,
-  stepOut = 7,
-  updateMarkup = 8,
-  permutationListEntry = 9,
-  permutationListEnd = 10,
-}
-
-export enum FrameType {
-  // The values must be kept in sync with the .NET equivalent in RenderTreeFrameType.cs
-  element = 1,
-  text = 2,
-  attribute = 3,
-  component = 4,
-  region = 5,
-  elementReferenceCapture = 6,
-  markup = 8,
-}