@qwik.dev/core 2.0.0-beta.11 → 2.0.0-beta.13

package/dist/testing/index.d.ts

@@ -11,6 +11,13 @@ import type { _Stringifiable } from '../internal';
 import type { _VirtualVNode } from '../internal';
 import type { _VNode } from '../internal';
 
+declare interface AddRootFn {
+    (obj: unknown, returnRef?: never): number;
+    (obj: unknown, returnRef: true): SeenRef;
+}
+
+declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags;
+
 declare type AsyncComputedCtx = {
     track: Tracker;
     cleanup: (callback: () => void) => void;
@@ -43,7 +50,7 @@ declare interface Chore<T extends ChoreType = ChoreType> {
     $target$: ChoreTarget | null;
     $payload$: unknown;
     $state$: ChoreState;
-    $blockedChores$: Chore[] | null;
+    $blockedChores$: ChoreArray | null;
     $startTime$: number | undefined;
     $endTime$: number | undefined;
     $resolve$: ((value: any) => void) | undefined;
@@ -343,9 +350,9 @@ declare interface ElementFixtureOptions {
 declare class ElementVNode extends VNode {
     firstChild: VNode | null | undefined;
     lastChild: VNode | null | undefined;
-    element: Element;
+    element: QElement;
     elementName: string | undefined;
-    constructor(flags: VNodeFlags, parent: ElementVNode | VirtualVNode | null, previousSibling: VNode | null | undefined, nextSibling: VNode | null | undefined, firstChild: VNode | null | undefined, lastChild: VNode | null | undefined, element: Element, elementName: string | undefined);
+    constructor(flags: VNodeFlags, parent: ElementVNode | VirtualVNode | null, previousSibling: VNode | null | undefined, nextSibling: VNode | null | undefined, firstChild: VNode | null | undefined, lastChild: VNode | null | undefined, element: QElement, elementName: string | undefined);
 }
 
 /** @public */
@@ -373,8 +380,6 @@ declare type HostElement = VNode | ISsrNode;
 /** The shared state during an invoke() call */
 declare interface InvokeContext {
     $url$: URL | undefined;
-    /** The next available index for the sequentialScope array */
-    $i$: number;
     /** The Virtual parent component for the current component code */
     $hostElement$: HostElement | undefined;
     /** The current DOM element */
@@ -469,6 +474,11 @@ declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof Task
 
 declare type Props = Record<string, unknown>;
 
+declare interface QElement extends Element {
+    qDispatchEvent?: (event: Event, scope: QwikLoaderEventScope) => boolean;
+    vNode?: VNode;
+}
+
 /**
  * The `QRL` type represents a lazy-loadable AND serializable resource.
  *
@@ -633,6 +643,8 @@ declare type QRLInternalMethods<TYPE> = {
 
 declare type QrlReturn<T> = T extends (...args: any) => infer R ? Awaited<R> : unknown;
 
+declare type QwikLoaderEventScope = '-document' | '-window' | '';
+
 /** @public */
 declare interface ReadonlySignal<T = unknown> {
     readonly value: T;
@@ -655,10 +667,10 @@ declare interface ResourceReturnInternal<T> {
 
 declare type Scheduler = ReturnType<typeof createScheduler>;
 
+/** Stores the location of an object. If no parent, it's a root. */
 declare type SeenRef = {
-    $parent$: unknown | null;
     $index$: number;
-    $rootIndex$: number;
+    $parent$?: SeenRef | null;
 };
 
 declare interface SerializationContext {
@@ -674,28 +686,21 @@ declare interface SerializationContext {
      * - `{ parent, index }` - The parent object and the index within that parent.
      * - `undefined` - Object has not been seen yet.
      */
-    $wasSeen$: (obj: unknown) => SeenRef | undefined;
+    getSeenRef: (obj: unknown) => SeenRef | undefined;
+    /** Returns the root index of the object, if it is a root. Otherwise returns undefined. */
     $hasRootId$: (obj: unknown) => number | undefined;
     /**
      * Root objects which need to be serialized.
      *
      * Roots are entry points into the object graph. Typically the roots are held by the listeners.
      *
-     * Returns a path string representing the path from roots through all parents to the object.
-     * Format: "3 2 0" where each number is the index within its parent, from root to leaf.
+     * Returns the index of the root object.
      */
-    $addRoot$: (obj: unknown, parent?: unknown) => number;
-    /**
-     * Get root path of the object without creating a new root.
-     *
-     * This is used during serialization, as new roots can't be created during serialization.
-     *
-     * The function throws if the root was not found.
-     */
-    $addRootPath$: (obj: any) => string | number;
-    $seen$: (obj: unknown, parent: unknown | null, index: number) => void;
+    $addRoot$: AddRootFn;
+    /** 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[];
-    $objectPathStringCache$: Map<unknown, string | number>;
+    $promoteToRoot$: (ref: SeenRef, index?: number) => void;
     $addSyncFn$($funcStr$: string | null, argsCount: number, fn: Function): number;
     $isSsrNode$: (obj: unknown) => obj is SsrNode;
     $isDomRef$: (obj: unknown) => obj is DomRef;
@@ -710,6 +715,11 @@ declare interface SerializationContext {
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
 
+declare const enum SerializationSignalFlags {
+    SERIALIZATION_STRATEGY_NEVER = 16,
+    SERIALIZATION_STRATEGY_ALWAYS = 32
+}
+
 /**
  * A signal is a reactive value which can be read and written. When the signal is written, all tasks
  * which are tracking the signal will be re-run and all components that read the signal will be
@@ -726,11 +736,17 @@ declare interface Signal<T = any> extends ReadonlySignal<T> {
     value: T;
 }
 
+declare const enum SignalFlags {
+    INVALID = 1,
+    RUN_EFFECTS = 2
+}
+
 declare class SignalImpl<T = any> implements Signal<T> {
     $untrackedValue$: T;
     /** Store a list of effects which are dependent on this signal. */
     $effects$: null | Set<EffectSubscription>;
     $container$: Container | null;
+    $wrappedSignal$: WrappedSignalImpl<T> | null;
     constructor(container: Container | null, value: T);
     /**
      * Use this to force running subscribers, for example when the calculated value has mutated but
@@ -758,7 +774,7 @@ declare type SsrAttrKey = string;
 
 declare type SsrAttrs = Array<SsrAttrKey | SsrAttrValue>;
 
-declare type SsrAttrValue = string | Signal<any> | boolean | object | null;
+declare type SsrAttrValue = string | Signal<any> | Promise<any> | boolean | object | null;
 
 /** A selection of attributes of the real thing */
 declare type SsrNode = {
@@ -774,8 +790,14 @@ declare const enum SsrNodeFlags {
 
 /** @public */
 export declare function ssrRenderToDom(jsx: JSXOutput, opts?: {
+    /** Print debug information to console. */
     debug?: boolean;
+    /** Treat JSX as raw, (don't wrap in in head/body) */
     raw?: boolean;
+    /** Include QwikLoader */
+    qwikLoader?: boolean;
+    /** Inject nodes into the document before test runs (for testing purposes) */
+    onBeforeResume?: (document: Document) => void;
 }): Promise<{
     container: _DomContainer;
     document: Document;
@@ -921,7 +943,8 @@ declare interface Tracker {
 }
 
 /**
- * Trigger an event in unit tests on an element.
+ * Trigger an event in unit tests on an element. Needs to be kept in sync with the Qwik Loader event
+ * dispatching.
  *
  * Future deprecation candidate.
  *
@@ -1065,8 +1088,9 @@ declare const enum VNodeJournalOpCode {
     SetText = 1,// ------ [SetAttribute, target, text]
     SetAttribute = 2,// - [SetAttribute, target, ...(key, values)]]
     HoistStyles = 3,// -- [HoistStyles, document]
-    Remove = 4,// ------- [Insert, target(parent), ...nodes]
-    Insert = 5
+    Remove = 4,// ------- [Remove, target(parent), ...nodes]
+    RemoveAll = 5,// ------- [RemoveAll, target(parent)]
+    Insert = 6
 }
 
 /**
@@ -1086,4 +1110,29 @@ export declare function walkJSX(jsx: JSXOutput, apply: {
     text: (text: _Stringifiable) => void;
 }): void;
 
+declare const enum WrappedSignalFlags {
+    UNWRAP = 4
+}
+
+declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
+    $args$: any[];
+    $func$: (...args: any[]) => T;
+    $funcStr$: string | null;
+    $flags$: AllSignalFlags;
+    $hostElement$: HostElement | null;
+    [_EFFECT_BACK_REF]: Map<EffectProperty | string, EffectSubscription> | null;
+    constructor(container: Container | null, fn: (...args: any[]) => T, args: any[], fnStr: string | null, flags?: SignalFlags);
+    invalidate(): void;
+    /**
+     * Use this to force running subscribers, for example when the calculated value has mutated but
+     * remained the same object.
+     */
+    force(): void;
+    get untrackedValue(): T;
+    $computeIfNeeded$(): void;
+    $unwrapIfSignal$(): SignalImpl<T> | WrappedSignalImpl<T>;
+    set value(_: any);
+    get value(): any;
+}
+
 export { }