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

package/dist/testing/index.d.ts

@@ -1,4 +1,5 @@
-import { ClientContainer } from '../internal';
+import { ClientContainer } from '..';
+import type { ClientContainer as ClientContainer_2 } from '../internal';
 import type { CorePlatform } from '..';
 import type { _DomContainer } from '../internal';
 import type { _ElementVNode } from '../internal';
@@ -6,11 +7,17 @@ import type { JSXNodeInternal } from '../internal';
 import { JSXOutput } from '..';
 import type { _QDocument } from '../internal';
 import { RenderResult } from '..';
-import type { StreamWriter as StreamWriter_2 } from '..';
 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;
@@ -51,6 +58,11 @@ declare interface Chore<T extends ChoreType = ChoreType> {
     $returnValue$: ValueOrPromise<ChoreReturnValue<T>>;
 }
 
+declare class ChoreArray extends Array<Chore> {
+    add(value: Chore): number;
+    delete(value: Chore): number;
+}
+
 declare type ChoreReturnValue<T extends ChoreType = ChoreType> = T extends ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS | ChoreType.WAIT_FOR_QUEUE | ChoreType.NODE_PROP ? void : T extends ChoreType.NODE_DIFF | ChoreType.COMPONENT ? JSXOutput_2 : unknown;
 
 declare enum ChoreState {
@@ -207,10 +219,10 @@ export declare const createDOM: ({ html }?: {
     userEvent: (queryOrElement: string | Element | keyof HTMLElementTagNameMap | null, eventNameCamel: string | keyof WindowEventMap, eventPayload?: any) => Promise<void>;
 }>;
 
-declare const createScheduler: (container: Container, journalFlush: () => void, choreQueue?: Chore[], blockedChores?: Set<Chore>, runningChores?: Set<Chore>) => {
+declare const createScheduler: (container: Container, journalFlush: () => void, choreQueue: ChoreArray, blockedChores: Set<Chore>, runningChores: Set<Chore>) => {
     (type: ChoreType.QRL_RESOLVE, ignore: null, target: ComputeQRL<any> | AsyncComputeQRL<any>): Chore<ChoreType.QRL_RESOLVE>;
     (type: ChoreType.WAIT_FOR_QUEUE): Chore<ChoreType.WAIT_FOR_QUEUE>;
-    (type: ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, host: HostElement | null, target: Signal | StoreHandler, effects: Set<EffectSubscription> | null): Chore<ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS>;
+    (type: ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS, host: HostElement | null, target: Signal<unknown> | StoreTarget, effects: Set<EffectSubscription> | null): Chore<ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS>;
     (type: ChoreType.TASK | ChoreType.VISIBLE, task: Task): Chore<ChoreType.TASK | ChoreType.VISIBLE>;
     (type: ChoreType.RUN_QRL, host: HostElement, target: QRLInternal<(...args: unknown[]) => unknown>, args: unknown[]): Chore<ChoreType.RUN_QRL>;
     (type: ChoreType.COMPONENT, host: HostElement, qrl: QRLInternal<OnRenderFn<unknown>>, props: Props | null): Chore<ChoreType.COMPONENT>;
@@ -335,25 +347,13 @@ declare interface ElementFixtureOptions {
 }
 
 /** @internal */
-declare type ElementVNode = [
-VNodeFlags.Element,
-////////////// 0 - Flags
-VNode | null,
-/////////////// 1 - Parent
-VNode | null,
-/////////////// 2 - Previous sibling
-VNode | null,
-/////////////// 3 - Next sibling
-VNode | null | undefined,
-/// 4 - First child - undefined if children need to be materialize
-VNode | null | undefined,
-Element,
-//////////////////// 6 - Element
-string | undefined,
-(string | null)[]
-] & {
-    __brand__: 'ElementVNode';
-};
+declare class ElementVNode extends VNode {
+    firstChild: VNode | null | undefined;
+    lastChild: VNode | null | undefined;
+    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: QElement, elementName: string | undefined);
+}
 
 /** @public */
 export declare function emulateExecutionOfQwikFuncs(document: Document): void;
@@ -380,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 */
@@ -476,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.
  *
@@ -640,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;
@@ -662,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 {
@@ -681,32 +686,25 @@ 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;
-    $writer$: StreamWriter_2;
+    $writer$: StreamWriter;
     $syncFns$: string[];
     $eventQrls$: Set<QRL>;
     $eventNames$: Set<string>;
@@ -717,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
@@ -733,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
@@ -765,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 = {
@@ -781,37 +790,21 @@ 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;
-    vNode: _VirtualVNode | null;
+    vNode: _VNode | null;
     getStyles: () => Record<string, string | string[]>;
 }>;
 
-declare const enum StoreFlags {
-    NONE = 0,
-    RECURSIVE = 1,
-    IMMUTABLE = 2
-}
-
-declare class StoreHandler implements ProxyHandler<StoreTarget> {
-    $flags$: StoreFlags;
-    $container$: Container | null;
-    $effects$: null | Map<string | symbol, Set<EffectSubscription>>;
-    constructor($flags$: StoreFlags, $container$: Container | null);
-    toString(): string;
-    force(prop: keyof StoreTarget): void;
-    get(target: StoreTarget, prop: string | symbol): any;
-    /** In the case of oldValue and value are the same, the effects are not triggered. */
-    set(target: StoreTarget, prop: string | symbol, value: any): boolean;
-    deleteProperty(target: StoreTarget, prop: string | symbol): boolean;
-    has(target: StoreTarget, prop: string | symbol): boolean;
-    ownKeys(target: StoreTarget): ArrayLike<string | symbol>;
-    getOwnPropertyDescriptor(target: StoreTarget, prop: string | symbol): PropertyDescriptor | undefined;
-}
-
 declare type StoreTarget = Record<string | symbol, any>;
 
 /** @internal */
@@ -864,22 +857,6 @@ declare interface TestPlatform extends CorePlatform {
     flush: () => Promise<void>;
 }
 
-/** @internal */
-declare type TextVNode = [
-VNodeFlags.Text | VNodeFlags.Inflated,
-// 0 - Flags
-VNode | null,
-///////////////// 1 - Parent
-VNode | null,
-///////////////// 2 - Previous sibling
-VNode | null,
-///////////////// 3 - Next sibling
-Text | null | undefined,
-string
-] & {
-    __brand__: 'TextVNode';
-};
-
 /**
  * Used to signal to Qwik which state should be watched for changes.
  *
@@ -966,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.
  *
@@ -984,32 +962,36 @@ export declare function trigger(root: Element, queryOrElement: string | Element
 declare type ValueOrPromise<T> = T | Promise<T>;
 
 /** @internal */
-declare type VirtualVNode = [
-VNodeFlags.Virtual,
-///////////// 0 - Flags
-VNode | null,
-/////////////// 1 - Parent
-VNode | null,
-/////////////// 2 - Previous sibling
-VNode | null,
-/////////////// 3 - Next sibling
-VNode | null,
-/////////////// 4 - First child
-VNode | null,
-(string | null | boolean)[]
-] & {
-    __brand__: 'FragmentNode' & 'HostElement';
-};
+declare class VirtualVNode extends VNode {
+    firstChild: VNode | null | undefined;
+    lastChild: VNode | null | undefined;
+    constructor(flags: VNodeFlags, parent: ElementVNode | VirtualVNode | null, previousSibling: VNode | null | undefined, nextSibling: VNode | null | undefined, firstChild: VNode | null | undefined, lastChild: VNode | null | undefined);
+}
 
 /** @internal */
-declare type VNode = ElementVNode | TextVNode | VirtualVNode;
+declare abstract class VNode extends BackRef {
+    flags: VNodeFlags;
+    parent: ElementVNode | VirtualVNode | null;
+    previousSibling: VNode | null | undefined;
+    nextSibling: VNode | null | undefined;
+    props: unknown[] | null;
+    slotParent: VNode | null;
+    chores: ChoreArray | null;
+    blockedChores: ChoreArray | null;
+    constructor(flags: VNodeFlags, parent: ElementVNode | VirtualVNode | null, previousSibling: VNode | null | undefined, nextSibling: VNode | null | undefined);
+    getProp<T>(key: string, getObject: ((id: string) => any) | null): T | null;
+    setProp(key: string, value: any): void;
+    getAttr(key: string): string | null;
+    setAttr(key: string, value: string | null | boolean, journal: VNodeJournal | null): void;
+    toString(): string;
+}
 
 /** @public */
 export declare function vnode_fromJSX(jsx: JSXOutput): {
-    vParent: _ElementVNode;
+    vParent: _ElementVNode | _VirtualVNode;
     vNode: _VNode | null;
     document: _QDocument;
-    container: ClientContainer;
+    container: ClientContainer_2;
 };
 
 /**
@@ -1092,6 +1074,25 @@ declare const enum VNodeFlags {
     NS_math = 128
 }
 
+declare type VNodeJournal = Array<VNodeJournalOpCode | Document | Element | Text | string | boolean | null>;
+
+/**
+ * Fundamental DOM operations are:
+ *
+ * - Insert new DOM element/text
+ * - Remove DOM element/text
+ * - Set DOM element attributes
+ * - Set text node value
+ */
+declare const enum VNodeJournalOpCode {
+    SetText = 1,// ------ [SetAttribute, target, text]
+    SetAttribute = 2,// - [SetAttribute, target, ...(key, values)]]
+    HoistStyles = 3,// -- [HoistStyles, document]
+    Remove = 4,// ------- [Remove, target(parent), ...nodes]
+    RemoveAll = 5,// ------- [RemoveAll, target(parent)]
+    Insert = 6
+}
+
 /**
  * Wait for the scheduler to drain.
  *
@@ -1109,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 { }