@qwik.dev/core 2.0.0-beta.34 → 2.0.0-beta.36

package/dist/testing/index.d.ts

@@ -7,6 +7,7 @@ import type { JSXNodeInternal } from '../internal';
 import { JSXOutput } from '..';
 import type { _QDocument } from '../internal';
 import { RenderResult } from '..';
+import { StreamWriter } from '..';
 import type { _Stringifiable } from '../internal';
 import type { _VirtualVNode } from '../internal';
 import type { _VNode } from '../internal';
@@ -45,13 +46,14 @@ declare const enum ChoreBits {
     TASKS = 1,
     NODE_DIFF = 2,
     COMPONENT = 4,
-    NODE_PROPS = 8,
-    COMPUTE = 16,
-    CHILDREN = 32,
-    CLEANUP = 64,
-    RECONCILE = 128,
-    ERROR_WRAP = 256,
-    DIRTY_MASK = 511
+    INLINE_COMPONENT = 8,
+    NODE_PROPS = 16,
+    COMPUTE = 32,
+    CHILDREN = 64,
+    CLEANUP = 128,
+    RECONCILE = 256,
+    ERROR_WRAP = 512,
+    DIRTY_MASK = 1023
 }
 
 /** @internal */
@@ -72,9 +74,12 @@ declare type Consumer = Task | VNode | SignalImpl | ISsrNode;
 declare interface Container {
     readonly $version$: string;
     readonly $storeProxyMap$: ObjToProxyMap;
+    $rootContainer$: Container | null;
+    $isOutOfOrderSegment$: boolean;
     readonly $locale$: string;
     readonly $getObjectById$: (id: number | string) => any;
     readonly $serverData$: Record<string, any>;
+    readonly $instanceHash$: string | null;
     $currentUniqueId$: number;
     $buildBase$: string | null;
     $renderPromise$: Promise<void> | null;
@@ -105,7 +110,7 @@ declare interface Container {
         new (...rest: any[]): {
             __brand__: 'DomRef';
         };
-    } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter): SerializationContext;
+    } | null, symbolToChunkResolver: SymbolToChunkResolver, writer?: StreamWriter_2): SerializationContext;
 }
 
 /**
@@ -203,7 +208,7 @@ declare interface DevJSX {
 }
 
 declare type DomRef = {
-    $ssrNode$: SsrNode;
+    $ssrNode$: ISsrNode;
 };
 
 /** @public */
@@ -321,6 +326,26 @@ export declare function getTestPlatform(): TestPlatform;
 
 declare type HostElement = VNode | ISsrNode;
 
+/** @public */
+export declare interface InOrderAuto {
+    strategy: 'auto';
+    maximumInitialChunk?: number;
+    maximumChunk?: number;
+}
+
+/** @public */
+export declare interface InOrderDirect {
+    strategy: 'direct';
+}
+
+/** @public */
+export declare interface InOrderDisabled {
+    strategy: 'disabled';
+}
+
+/** @public */
+export declare type InOrderStreaming = InOrderAuto | InOrderDisabled | InOrderDirect;
+
 /** The shared state during an invoke() call */
 declare interface InvokeContext {
     /** The Virtual parent component for the current component code */
@@ -337,8 +362,10 @@ declare interface ISsrNode {
     flags: SsrNodeFlags;
     dirty: ChoreBits;
     parentComponent: ISsrNode | null;
+    children: ISsrNode[] | null;
     vnodeData: VNodeData;
     currentFile: string | null;
+    readonly [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
     setProp(name: string, value: any): void;
     getProp(name: string): any;
     removeProp(name: string): void;
@@ -479,6 +506,9 @@ declare interface NodePropData {
 
 declare type ObjToProxyMap = WeakMap<any, any>;
 
+/** @public */
+export declare type OutOfOrderStreaming = boolean;
+
 /** @internal */
 declare const _OWNER: unique symbol;
 
@@ -705,6 +735,7 @@ declare type SeenRef = {
 
 declare interface SerializationContext {
     $serialize$: () => ValueOrPromise<void>;
+    $serializePatch$: (rootStart: number, rootIds: number[], extraRootId?: number | string | number[], streamedRootLimit?: number) => ValueOrPromise<void>;
     $symbolToChunkResolver$: SymbolToChunkResolver;
     /**
      * Map from object to parent and index reference.
@@ -727,14 +758,26 @@ declare interface SerializationContext {
      * Returns the index of the root object.
      */
     $addRoot$: AddRootFn;
+    $addDuplicateRoot$: (obj: unknown) => SeenRef;
+    $commitRoot$: (root: unknown, obj: unknown) => number;
     /** Mark an object as seen during serialization. This is used to handle backreferences and cycles */
     $markSeen$: (obj: unknown, parent: SeenRef | undefined, index: number) => SeenRef;
     $roots$: unknown[];
-    $promoteToRoot$: (ref: SeenRef, index?: number) => void;
+    $rootObjs$: unknown[];
+    $onAddRoot$?: (id: number, root: unknown, obj: unknown) => void;
+    $forwardRefOffset$: number;
+    $serializedRootCount$: number;
+    $serializedForwardRefCount$: number;
+    $rootStateRootCount$: number;
+    $hasRootStateForwardRefs$: boolean;
+    $promoteToRoot$: (ref: SeenRef, obj: unknown, index?: number) => void;
     $addSyncFn$($funcStr$: string | null, argsCount: number, fn: Function): number;
-    $isSsrNode$: (obj: unknown) => obj is SsrNode;
+    $setSyncFnOffset$(offset: number, existingFns?: string[]): void;
+    $isSsrNode$: (obj: unknown) => obj is ISsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
-    $writer$: StreamWriter;
+    $markSsrNodeForSerialization$: (node: ISsrNode, flags: number) => void;
+    $writer$: SSRInternalStreamWriter;
+    $setWriter$(writer: SSRInternalStreamWriter): void;
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
@@ -810,13 +853,12 @@ declare interface SimplifiedServerRequestEvent<T = unknown> {
     request: Request;
 }
 
-/** A selection of attributes of the real thing */
-declare type SsrNode = {
-    id: string;
-    children: ISsrNode[] | null;
-    vnodeData: VNodeData;
-    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
-};
+/** @internal */
+declare interface SSRInternalStreamWriter extends StreamWriter_2 {
+    writeRootRef(id: number): ValueOrPromise<void>;
+    writeRootRefPath(path: number[]): ValueOrPromise<void>;
+    toString(remap?: number[]): string;
+}
 
 declare const enum SsrNodeFlags {
     Updatable = 1
@@ -830,6 +872,14 @@ export declare function ssrRenderToDom(jsx: JSXOutput, opts?: {
     raw?: boolean;
     /** Include QwikLoader */
     qwikLoader?: boolean;
+    /** Override the SSR container tag name. */
+    containerTagName?: string;
+    /** Stream rendered chunks while still collecting the final HTML. */
+    stream?: StreamWriter;
+    /** Configure SSR streaming. */
+    streaming?: StreamingOptions;
+    /** Skip client resume emulation after SSR. */
+    resume?: boolean;
     /** Inject nodes into the document before test runs (for testing purposes) */
     onBeforeResume?: (document: Document) => void;
 }): Promise<{
@@ -841,8 +891,14 @@ export declare function ssrRenderToDom(jsx: JSXOutput, opts?: {
 
 declare type StoreTarget = Record<string | symbol, any>;
 
+/** @public */
+export declare interface StreamingOptions {
+    inOrder?: InOrderStreaming;
+    outOfOrder?: OutOfOrderStreaming;
+}
+
 /** @internal */
-declare interface StreamWriter {
+declare interface StreamWriter_2 {
     write(chunk: string): ValueOrPromise<void>;
     waitForDrain?(): ValueOrPromise<void>;
 }