@qwik.dev/core 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/testing/index.d.ts

@@ -18,37 +18,9 @@ declare interface AddRootFn {
 
 declare type AllSignalFlags = SignalFlags | WrappedSignalFlags | SerializationSignalFlags | AsyncSignalFlags;
 
-/** @public */
-declare interface AsyncSignal<T = unknown> extends ComputedSignal<T> {
-    /**
-     * Whether the signal is currently loading. This will trigger lazy loading of the signal, so you
-     * can use it like this:
-     *
-     * ```tsx
-     * signal.loading ? <Loading /> : signal.error ? <Error /> : <Component
-     * value={signal.value} />
-     * ```
-     */
-    loading: boolean;
-    /**
-     * The error that occurred while computing the signal, if any. This will be cleared when the
-     * signal is successfully computed.
-     */
-    error: Error | undefined;
-    /**
-     * Poll interval in ms. Writable and immediately effective when the signal has consumers. If set
-     * to `0`, polling stops.
-     */
-    interval: number;
-    /** A promise that resolves when the value is computed or rejected. */
-    promise(): Promise<void>;
-    /** Abort the current computation and run cleanups if needed. */
-    abort(reason?: any): void;
-}
-
 declare const enum AsyncSignalFlags {
     EAGER_CLEANUP = 32,
-    AWAIT_PREVIOUS = 64
+    CLIENT_ONLY = 64
 }
 
 /** Class for back reference to the EffectSubscription */
@@ -78,25 +50,8 @@ declare const enum ChoreBits {
     DIRTY_MASK = 127
 }
 
-/**
- * A computed signal is a signal which is calculated from other signals. When the signals change,
- * the computed signal is recalculated, and if the result changed, all tasks which are tracking the
- * signal will be re-run and all components that read the signal will be re-rendered.
- *
- * @public
- */
-declare interface ComputedSignal<T> extends ReadonlySignal<T> {
-    /**
-     * Use this to force running subscribers, for example when the calculated value mutates but
-     * remains the same object.
-     */
-    force(): void;
-    /**
-     * Use this to force recalculation and running subscribers, for example when the calculated value
-     * mutates but remains the same object.
-     */
-    invalidate(): void;
-}
+/** @internal */
+declare const _CONST_PROPS: unique symbol;
 
 /**
  * Effect is something which needs to happen (side-effect) due to signal value change.
@@ -235,6 +190,14 @@ declare interface DescriptorBase<T = unknown, B = unknown> extends BackRef {
     $destroy$: (() => void) | null;
 }
 
+/** @public */
+declare interface DevJSX {
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+    stack?: string;
+}
+
 declare type DomRef = {
     $ssrNode$: SsrNode;
 };
@@ -252,6 +215,8 @@ export declare function domRender(jsx: JSXOutput, opts?: {
 /** @internal */
 declare const _EFFECT_BACK_REF: unique symbol;
 
+declare type EffectBackRef = SignalImpl | StoreTarget | PropsProxy;
+
 declare const enum EffectProperty {
     COMPONENT = ":",
     VNODE = "."
@@ -296,9 +261,9 @@ declare const enum EffectProperty {
 declare class EffectSubscription {
     consumer: Consumer;
     property: EffectProperty | string;
-    backRef: Set<SignalImpl | StoreTarget> | null;
+    backRef: Set<EffectBackRef> | null;
     data: SubscriptionData | null;
-    constructor(consumer: Consumer, property: EffectProperty | string, backRef?: Set<SignalImpl | StoreTarget> | null, data?: SubscriptionData | null);
+    constructor(consumer: Consumer, property: EffectProperty | string, backRef?: Set<EffectBackRef> | null, data?: SubscriptionData | null);
 }
 
 /**
@@ -336,6 +301,17 @@ export declare function emulateExecutionOfQwikFuncs(document: Document): void;
 /** @public */
 export declare function expectDOM(actual: Element, expected: string): Promise<void>;
 
+/**
+ * Any function taking a props object that returns JSXOutput.
+ *
+ * The `key`, `flags` and `dev` parameters are for internal use.
+ *
+ * @public
+ */
+declare type FunctionComponent<P = unknown> = {
+    renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput_2;
+}['renderFn'];
+
 /** @public */
 export declare function getTestPlatform(): TestPlatform;
 
@@ -366,6 +342,84 @@ declare interface ISsrNode {
     setTreeNonUpdatable(): void;
 }
 
+/** @public */
+declare type JSXChildren = string | number | boolean | null | undefined | Function | RegExp | JSXChildren[] | Promise<JSXChildren> | Signal<JSXChildren> | JSXNode;
+
+/**
+ * A JSX Node, an internal structure. You probably want to use `JSXOutput` instead.
+ *
+ * @public
+ */
+declare interface JSXNode<T extends string | FunctionComponent | unknown = unknown> {
+    type: T;
+    props: T extends FunctionComponent<infer P> ? P : Record<any, unknown>;
+    children: JSXChildren | null;
+    key: string | null;
+    dev?: DevJSX;
+}
+
+declare class JSXNodeImpl<T = unknown> implements JSXNodeInternal_2<T> {
+    type: T;
+    children: JSXChildren;
+    toSort: boolean;
+    key: string | null;
+    varProps: Props;
+    constProps: Props | null;
+    dev?: DevJSX & {
+        stack: string | undefined;
+    };
+    _proxy: Props | null;
+    constructor(type: T, varProps: Props | null, constProps: Props | null, children: JSXChildren, key: string | number | null | undefined, toSort?: boolean, dev?: DevJSX);
+    get props(): T extends FunctionComponent<infer PROPS> ? PROPS : Props;
+}
+
+/**
+ * The internal representation of a JSX Node.
+ *
+ * @internal
+ */
+declare interface JSXNodeInternal_2<T extends string | FunctionComponent | unknown = unknown> extends JSXNode<T> {
+    /** The type of node */
+    type: T;
+    /** Do the varProps need sorting */
+    toSort: boolean;
+    /** The key property */
+    key: string | null;
+    /**
+     * Props that are not guaranteed shallow equal across runs.
+     *
+     * Any prop that is in `constProps` takes precedence over `varProps`.
+     *
+     * Does not contain `children` or `key`.
+     *
+     * `onEvent$` props are normalized to the html `q-x:event` version
+     */
+    varProps: Props;
+    /**
+     * Props that will be shallow equal across runs. Does not contain any props that are in varProps.
+     *
+     * Any prop that is in `constProps` takes precedence over `varProps`.
+     *
+     * Does not contain `children` or `key`.
+     *
+     * `onEvent$` props are normalized to the html `q-x:event` version
+     */
+    constProps: Props | null;
+    /** The children of the node */
+    children: JSXChildren;
+    /** Filename etc for debugging */
+    dev?: DevJSX & {
+        stack: string | undefined;
+    };
+}
+
+/**
+ * Any valid output for a component
+ *
+ * @public
+ */
+declare type JSXOutput_2 = JSXNode | string | number | boolean | null | undefined | JSXOutput_2[];
+
 /** @public */
 declare interface MockDocument extends Document {
 }
@@ -392,10 +446,36 @@ declare interface NodePropData {
 
 declare type ObjToProxyMap = WeakMap<any, any>;
 
+/** @internal */
+declare const _OWNER: unique symbol;
+
 declare type PossibleEvents = Event | SimplifiedServerRequestEvent | typeof TaskEvent | typeof RenderEvent;
 
 declare type Props = Record<string, unknown>;
 
+/** @internal */
+declare const _PROPS_HANDLER: unique symbol;
+
+declare type PropsProxy = {
+    [_VAR_PROPS]: Props;
+    [_CONST_PROPS]: Props | null;
+    [_OWNER]: JSXNodeInternal_2;
+    [_PROPS_HANDLER]: PropsProxyHandler;
+} & Record<string | symbol, unknown>;
+
+declare class PropsProxyHandler implements ProxyHandler<any> {
+    owner: JSXNodeImpl;
+    $effects$: undefined | Map<string | symbol, Set<EffectSubscription>>;
+    $container$: Container | null;
+    constructor(owner: JSXNodeImpl);
+    get(_: any, prop: string | symbol): any;
+    set(_: any, prop: string | symbol, value: any): boolean;
+    deleteProperty(_: any, prop: string | symbol): boolean;
+    has(_: any, prop: string | symbol): boolean;
+    getOwnPropertyDescriptor(_: any, p: string | symbol): PropertyDescriptor | undefined;
+    ownKeys(): string[];
+}
+
 /**
  * The `QRL` type represents a lazy-loadable AND serializable resource.
  *
@@ -567,22 +647,8 @@ declare type QRLInternalMethods<TYPE> = {
 
 declare type QrlReturn<T> = T extends (...args: any) => infer R ? Awaited<R> : unknown;
 
-/** @public */
-declare interface ReadonlySignal<T = unknown> {
-    readonly value: T;
-}
-
 declare const RenderEvent = "qRender";
 
-declare interface ResourceReturnInternal<T> {
-    __brand: 'resource';
-    value: Promise<T>;
-    loading: boolean;
-    signal: AsyncSignal<{
-        r: T;
-    }>;
-}
-
 /** Stores the location of an object. If no parent, it's a root. */
 declare type SeenRef = {
     $index$: number;
@@ -627,14 +693,13 @@ declare interface SerializationContext {
     $renderSymbols$: Set<string>;
     $storeProxyMap$: ObjToProxyMap;
     $eagerResume$: Set<unknown>;
-    $resources$: Set<ResourceReturnInternal<any>>;
-    $getProp$: (obj: any, prop: string) => any;
     $setProp$: (obj: any, prop: string, value: any) => void;
 }
 
 declare const enum SerializationSignalFlags {
     SERIALIZATION_STRATEGY_NEVER = 8,
-    SERIALIZATION_STRATEGY_ALWAYS = 16
+    SERIALIZATION_STRATEGY_ALWAYS = 16,
+    SERIALIZATION_ALL_STRATEGIES = 24
 }
 
 /**
@@ -649,8 +714,16 @@ declare const enum SerializationSignalFlags {
  *
  * @public
  */
-declare interface Signal<T = any> extends ReadonlySignal<T> {
+declare interface Signal<T = any> {
+    /** Reading from this subscribes to updates; writing to this triggers updates. */
     value: T;
+    /** Reading from this does not subscribe to updates; writing to this does not trigger updates. */
+    untrackedValue: T;
+    /**
+     * Use this to trigger running subscribers, for example when the value mutated but remained the
+     * same object.
+     */
+    trigger(): void;
 }
 
 declare const enum SignalFlags {
@@ -666,9 +739,11 @@ declare class SignalImpl<T = any> implements Signal<T> {
     $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
+     * Use this to trigger running subscribers, for example when the calculated value has mutated but
      * remained the same object
      */
+    trigger(): void;
+    /** @deprecated Use `trigger()` instead */
     force(): void;
     get untrackedValue(): T;
     set untrackedValue(value: T);
@@ -681,20 +756,12 @@ declare class SignalImpl<T = any> implements Signal<T> {
     };
 }
 
-declare type SimpleSsrAttrValue = string | Signal<SimpleSsrAttrValue> | boolean | object | null;
-
 declare interface SimplifiedServerRequestEvent<T = unknown> {
     url: URL;
     locale: string | undefined;
     request: Request;
 }
 
-declare type SsrAttrKey = string;
-
-declare type SsrAttrs = Array<SsrAttrKey | SsrAttrValue>;
-
-declare type SsrAttrValue = SimpleSsrAttrValue | Promise<SimpleSsrAttrValue>;
-
 /** A selection of attributes of the real thing */
 declare type SsrNode = {
     id: string;
@@ -797,6 +864,9 @@ export declare function trigger(root: Element, queryOrElement: string | Element
  */
 declare type ValueOrPromise<T> = T | Promise<T>;
 
+/** @internal */
+declare const _VAR_PROPS: unique symbol;
+
 /** @internal */
 declare abstract class VNode implements BackRef {
     flags: VNodeFlags;
@@ -848,7 +918,7 @@ export declare function vnode_fromJSX(jsx: JSXOutput): {
  * this data needs to be serialized into a string and stored in the DOM as a script tag which has
  * deferent serialization format.
  */
-declare type VNodeData = [VNodeDataFlag, ...(SsrAttrs | number)[]];
+declare type VNodeData = [VNodeDataFlag, ...(Props | number)[]];
 
 /**
  * Flags for VNodeData (Flags con be bitwise combined)
@@ -925,7 +995,7 @@ declare const enum WrappedSignalFlags {
     UNWRAP = 4
 }
 
-declare class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
+declare class WrappedSignalImpl<T> extends SignalImpl<T> {
     $args$: any[];
     $func$: (...args: any[]) => T;
     $funcStr$: string | null;