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

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,26 +50,6 @@ 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;
-}
-
 /**
  * Effect is something which needs to happen (side-effect) due to signal value change.
  *
@@ -567,22 +519,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 +565,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 +586,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 +611,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 +628,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;
@@ -848,7 +787,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 +864,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;